other:merge 3.0

.gitignore

@@ -118,3 +118,12 @@ contrib/*
 !contrib/test
 sql
 debug*/
+.env
+tools/README
+tools/LICENSE
+tools/README.1ST
+tools/THANKS
+tools/NEWS
+tools/COPYING
+tools/BUGS
+tools/taos-tools
\ No newline at end of file

Jenkinsfile2

@@ -38,40 +38,21 @@ def pre_test(){
     sh '''
         cd ${WK}
         git reset --hard
+        git remote prune origin
+        git fetch
         cd ${WKC}
         git reset --hard
         git clean -fxd
+        git remote prune origin
+        git fetch
     '''
     script {
-        if (env.CHANGE_TARGET == 'master') {
-            sh '''
-                cd ${WK}
-                git checkout master
-                cd ${WKC}
-                git checkout master
-            '''
-        } else if(env.CHANGE_TARGET == '2.0') {
-            sh '''
-                cd ${WK}
-                git checkout 2.0
-                cd ${WKC}
-                git checkout 2.0
-            '''
-        } else if(env.CHANGE_TARGET == '3.0') {
-            sh '''
-                cd ${WK}
-                git checkout 3.0
-                cd ${WKC}
-                git checkout 3.0
-            '''
-        } else {
-            sh '''
-                cd ${WK}
-                git checkout develop
-                cd ${WKC}
-                git checkout develop
-            '''
-        }
+        sh '''
+            cd ${WK}
+            git checkout ''' + env.CHANGE_TARGET + '''
+            cd ${WKC}
+            git checkout ''' + env.CHANGE_TARGET + '''
+        '''
     }
     if (env.CHANGE_URL =~ /\/TDengine\//) {
         sh '''
@@ -169,49 +150,24 @@ def pre_test_win(){
     bat '''
         cd %WIN_INTERNAL_ROOT%
         git reset --hard
+        git remote prune origin
+        git fetch
     '''
     bat '''
         cd %WIN_COMMUNITY_ROOT%
         git reset --hard
+        git remote prune origin
+        git fetch
     '''
     script {
-        if (env.CHANGE_TARGET == 'master') {
-            bat '''
-                cd %WIN_INTERNAL_ROOT%
-                git checkout master
-            '''
-            bat '''
-                cd %WIN_COMMUNITY_ROOT%
-                git checkout master
-            '''
-        } else if(env.CHANGE_TARGET == '2.0') {
-            bat '''
-                cd %WIN_INTERNAL_ROOT%
-                git checkout 2.0
-            '''
-            bat '''
-                cd %WIN_COMMUNITY_ROOT%
-                git checkout 2.0
-            '''
-        } else if(env.CHANGE_TARGET == '3.0') {
-            bat '''
-                cd %WIN_INTERNAL_ROOT%
-                git checkout 3.0
-            '''
-            bat '''
-                cd %WIN_COMMUNITY_ROOT%
-                git checkout 3.0
-            '''
-        } else {
-            bat '''
-                cd %WIN_INTERNAL_ROOT%
-                git checkout develop
-            '''
-            bat '''
-                cd %WIN_COMMUNITY_ROOT%
-                git checkout develop
-            '''
-        }
+        bat '''
+            cd %WIN_INTERNAL_ROOT%
+            git checkout ''' + env.CHANGE_TARGET + '''
+        '''
+        bat '''
+            cd %WIN_COMMUNITY_ROOT%
+            git checkout ''' + env.CHANGE_TARGET + '''
+        '''
     }
     script {
         if (env.CHANGE_URL =~ /\/TDengine\//) {
@@ -309,6 +265,7 @@ def pre_test_build_win() {
     '''
     bat '''
         cd %WIN_CONNECTOR_ROOT%
+        python.exe -m pip install --upgrade pip
         python -m pip install .
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
     '''
@@ -327,6 +284,7 @@ def run_win_test() {
     bat '''
         echo "windows test ..."
         cd %WIN_CONNECTOR_ROOT%
+        python.exe -m pip install --upgrade pip
         python -m pip install .
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
         ls -l C:\\Windows\\System32\\taos.dll

README-CN.md

@@ -14,97 +14,60 @@
 [![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)
-[![tdengine](https://snapcraft.io//tdengine/badge.svg)](https://snapcraft.io/tdengine)
 
 简体中文 | [English](README.md) | 很多职位正在热招中，请看[这里](https://www.taosdata.com/cn/careers/)
 
 # TDengine 简介
 
-TDengine 是一款高性能、分布式、支持 SQL 的时序数据库（Time-Series Database）。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：
+TDengine 是一款开源、高性能、云原生的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供缓存、数据订阅、流式计算等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。与其他时序数据库相比，TDengine 的主要优势如下：
 
-- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
+- 高性能：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。
 
-- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
+- 云原生：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。
 
-- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
+- 极简时序数据平台：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。
 
-- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
+- 分析能力：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。
 
-- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
+- 简单易用：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。
 
-- **零学习成本**：采用 SQL 查询语言，支持 Python、Java、C/C++、Go、Rust、Node.js 等多种编程语言，与 MySQL 相似，零学习成本。
-
-- **无缝集成**：不用一行代码，即可与 Telegraf、Grafana、EMQX、Prometheus、StatsD、collectd、Matlab、R 等第三方工具无缝集成。
-
-- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
-
-TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域，让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。
+- 核心开源：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。
 
 # 文档
 
-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 文档](https://docs.taosdata.com) 或者  [English Documents](https://docs.tdengine.com)。
 
 # 构建
 
-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 目前可以在 Linux、 Windows 等平台上安装和运行。任何 OS 的应用也可以选择 taosAdapter 的 RESTful 接口连接服务端 taosd。CPU 支持 X64/ARM64，后续会支持 MIPS64、Alpha64、ARM32、RISC-V 等 CPU 架构。
+
+用户可根据需求选择通过源码、[容器](https://docs.taosdata.com/3.0/get-started/docker/)、[安装包](https://docs.taosdata.com/3.0/get-started/package/)或[Kubenetes](https://docs.taosdata.com/3.0/deployment/k8s/)来安装。本快速指南仅适用于通过源码安装。
+  
+TDengine 还提供一组辅助工具软件 taosTools，目前它包含 taosBenchmark（曾命名为 taosdemo）和 taosdump 两个软件。默认 TDengine 编译不包含 taosTools, 您可以在编译 TDengine 时使用`cmake .. -DBUILD_TOOLS=true` 来同时编译 taosTools。
 
 ## 安装工具
 
-### Ubuntu 16.04 及以上版本 & Debian：
+### Ubuntu 18.04 及以上版本 & Debian：
 
 ```bash
 sudo apt-get install -y gcc cmake build-essential git libssl-dev
 ```
 
-### Ubuntu 14.04：
-
-```bash
-sudo apt-get install -y gcc cmake3 build-essential git binutils-2.26
-export PATH=/usr/lib/binutils-2.26/bin:$PATH
-```
-
-编译或打包 JDBC 驱动源码，需安装 Java JDK 8 或以上版本和 Apache Maven 2.7 或以上版本。
-
-安装 OpenJDK 8：
-
-```bash
-sudo apt-get install -y openjdk-8-jdk
-```
-
-安装 Apache Maven：
-
-```bash
-sudo apt-get install -y  maven
-```
-
 #### 为 taos-tools 安装编译需要的软件
 
-taosTools 是用于 TDengine 的辅助工具软件集合。目前它包含 taosBenchmark（曾命名为 taosdemo）和 taosdump 两个软件。
-
-默认 TDengine 编译不包含 taosTools。您可以在编译 TDengine 时使用`cmake .. -DBUILD_TOOLS=true` 来同时编译 taosTools。
-
 为了在 Ubuntu/Debian 系统上编译 [taos-tools](https://github.com/taosdata/taos-tools) 需要安装如下软件：
 
 ```bash
 sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-dev pkg-config
 ```
 
-### CentOS 7：
-
-```bash
-sudo yum install -y gcc gcc-c++ make cmake git openssl-devel
-```
-
-安装 OpenJDK 8：
-
-```bash
-sudo yum install -y java-1.8.0-openjdk
-```
-
-安装 Apache Maven：
+### CentOS 7.9：
 
 ```bash
-sudo yum install -y maven
+sudo yum install epel-release
+sudo yum update
+sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
+sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 
 ### CentOS 8 & Fedora
@@ -113,33 +76,33 @@ sudo yum install -y maven
 sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 ```
 
-安装 OpenJDK 8：
+#### 在 CentOS 上构建 taosTools 安装依赖软件
+
+#### For CentOS 7/RHEL
 
-```bash
-sudo dnf install -y java-1.8.0-openjdk
+```
+sudo yum install -y zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
 ```
 
-安装 Apache Maven：
+#### For CentOS 8/Rocky Linux
 
-```bash
-sudo dnf install -y maven
+```
+sudo yum install -y epel-release
+sudo yum install -y dnf-plugins-core
+sudo yum config-manager --set-enabled powertools
+sudo yum install -y zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
 ```
 
-#### 在 CentOS 上构建 taosTools 安装依赖软件
-
-为了在 CentOS 上构建 [taosTools](https://github.com/taosdata/taos-tools) 需要安装如下依赖软件
+注意：由于 snappy 缺乏 pkg-config 支持（参考 [链接](https://github.com/google/snappy/pull/86)），会导致 cmake 提示无法发现 libsnappy，实际上工作正常。
 
-```bash
-sudo yum install zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
+若 powertools 安装失败，可以尝试改用：
+```
+sudo yum config-manager --set-enabled Powertools
 ```
-
-注意：由于 snappy 缺乏 pkg-config 支持
-（参考 [链接](https://github.com/google/snappy/pull/86)），会导致
-cmake 提示无法发现 libsnappy，实际上工作正常。
 
 ### 设置 golang 开发环境
 
-TDengine 包含数个使用 Go 语言开发的组件，请参考 golang.org 官方文档设置 go 开发环境。
+TDengine 包含数个使用 Go 语言开发的组件，比如taosAdapter, 请参考 golang.org 官方文档设置 go 开发环境。
 
 请使用 1.14 及以上版本。对于中国用户，我们建议使用代理来加速软件包下载。
 
@@ -148,6 +111,12 @@ go env -w GO111MODULE=on
 go env -w GOPROXY=https://goproxy.cn,direct
 ```
 
+缺省是不会构建 taosAdapter, 但您可以使用以下命令选择构建 taosAdapter 作为 RESTful 接口的服务。
+
+```
+cmake .. -DBUILD_HTTP=false
+```
+
 ### 设置 rust 开发环境
 
 TDengine 包含数个使用 Rust 语言开发的组件. 请参考 rust-lang.org 官方文档设置 rust 开发环境。
@@ -161,12 +130,7 @@ git clone https://github.com/taosdata/TDengine.git
 cd TDengine
 ```
 
-Go 连接器和 Grafana 插件在其他独立仓库，如果安装它们的话，需要在 TDengine 目录下通过此命令安装：
-
-```bash
-git submodule update --init --recursive
-```
-
+Go 连接器和 Grafana 插件已移到其他独立仓库。
 如果使用 https 协议下载比较慢，可以通过修改 ~/.gitconfig 文件添加以下两行设置使用 ssh 协议下载。需要首先上传 ssh 密钥到 GitHub，详细方法请参考 GitHub 官方文档。
 
 ```
@@ -187,7 +151,6 @@ git submodule update --init --recursive
 这个脚本等价于执行如下命令：
 
 ```bash
-git submodule update --init --recursive
 mkdir debug
 cd debug
 cmake .. -DBUILD_TOOLS=true
@@ -201,7 +164,7 @@ apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```
 
-在 X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
+在 X86-64、X86、arm64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 等。
 
 aarch64：
 
@@ -209,18 +172,6 @@ aarch64：
 cmake .. -DCPUTYPE=aarch64 && cmake --build .
 ```
 
-aarch32：
-
-```bash
-cmake .. -DCPUTYPE=aarch32 && cmake --build .
-```
-
-mips64：
-
-```bash
-cmake .. -DCPUTYPE=mips64 && cmake --build .
-```
-
 ### Windows 系统
 
 如果你使用的是 Visual Studio 2013 版本：
@@ -306,24 +257,6 @@ nmake install
 sudo make install
 ```
 
-安装成功后，如果想以服务形式启动，先配置 `.plist` 文件，在终端中执行：
-
-```bash
-sudo cp ../packaging/macOS/com.taosdata.tdengine.plist /Library/LaunchDaemons
-```
-
-在终端中启动 TDengine 服务：
-
-```bash
-sudo launchctl load /Library/LaunchDaemons/com.taosdata.tdengine.plist
-```
-
-在终端中停止 TDengine 服务：
-
-```bash
-sudo launchctl unload /Library/LaunchDaemons/com.taosdata.tdengine.plist
-```
-
 ## 快速运行
 
 如果不希望以服务方式运行 TDengine，也可以在终端中直接运行它。也即在生成完成后，执行以下命令（在 Windows 下，生成的可执行文件会带有 .exe 后缀，例如会名为 taosd.exe ）：
@@ -364,33 +297,14 @@ Query OK, 2 row(s) in set (0.001700s)
 
 TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：
 
-- [Java](https://www.taosdata.com/cn/documentation/connector/java)
-
+- [Java](https://docs.taosdata.com/reference/connector/java/)
 - [C/C++](https://www.taosdata.com/cn/documentation/connector#c-cpp)
-
-- [Python](https://www.taosdata.com/cn/documentation/connector#python)
-
-- [Go](https://www.taosdata.com/cn/documentation/connector#go)
-
-- [RESTful API](https://www.taosdata.com/cn/documentation/connector#restful)
-
-- [Node.js](https://www.taosdata.com/cn/documentation/connector#nodejs)
-
-- [Rust](https://www.taosdata.com/cn/documentation/connector/rust)
-
-## 第三方连接器
-
-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/examples/lua)
-
-# 运行和添加测试例
-
-TDengine 的测试框架和所有测试例全部开源。
-
-点击 [这里](https://github.com/taosdata/TDengine/blob/develop/tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
+- [Python](https://docs.taosdata.com/reference/connector/python/)
+- [Go](https://docs.taosdata.com/reference/connector/go/)
+- [Node.js](https://docs.taosdata.com/reference/connector/node/)
+- [Rust](https://docs.taosdata.com/reference/connector/rust/)
+- [C#](https://docs.taosdata.com/reference/connector/csharp/)
+- [RESTful API](https://docs.taosdata.com/reference/rest-api/)
 
 # 成为社区贡献者
 
@@ -399,7 +313,3 @@ TDengine 的测试框架和所有测试例全部开源。
 # 加入技术交流群
 
 TDengine 官方社群「物联网大数据群」对外开放，欢迎您加入讨论。搜索微信号 "tdengine"，加小 T 为好友，即可入群。
-
-# [谁在使用 TDengine](https://github.com/taosdata/TDengine/issues/2432)
-
-欢迎所有 TDengine 用户及贡献者在 [这里](https://github.com/taosdata/TDengine/issues/2432) 分享您在当前工作中开发/使用 TDengine 的故事。

README.md

@@ -20,78 +20,49 @@ English | [简体中文](README-CN.md) | We are hiring, check [here](https://tde
 
 # What is TDengine？
 
-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 subscription and other functionalities to reduce the complexity and cost of development and operation. TDengine differentiates itself from other TSDBs with the following advantages.
+TDengine is an open source, cloud native time-series database optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. TDengine differentiates itself from other TSDBs with the following advantages.:
 
-- **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.
+- High-Performance: TDengine is the only time-series database to solve the high cardinality issue to support billions of data collection points while out performing other time-series databases for data ingestion, querying and data compression.
 
-- **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.
+- Simplified Solution: Through built-in caching, stream processing and data subscription features, TDengine provides a simplified solution for time-series data processing. It reduces system design complexity and operation costs significantly.
 
-- **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.
+- Cloud Native: Through native distributed design, sharding and partitioning, separation of compute and storage, RAFT, support for kubernetes deployment and full observability, TDengine is a cloud native Time-Series Database and can be deployed on public, private or hybrid clouds.
 
-- **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.
+- Ease of Use: For administrators, TDengine significantly reduces the effort to deploy and maintain. For developers, it provides a simple interface, simplified solution and seamless integrations for third party tools. For data users, it gives easy data access. 
 
-- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, etc. More will be integrated.
+- Easy Data Analytics: Through super tables, storage and compute separation, data partitioning by time interval, pre-computation and other means, TDengine makes it easy to explore, format, and get access to data in a highly efficient way. 
 
-- **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.
+- Open Source: TDengine’s core modules, including cluster feature, are all available under open source licenses. It has gathered 18.8k stars on GitHub, an active developer community, and over 137k running instances worldwide.
 
 # Documentation
 
-For user manual, system design and architecture, engineering blogs, refer to [TDengine Documentation](https://www.taosdata.com/en/documentation/)(中文版请点击[这里](https://www.taosdata.com/cn/documentation20/))
-for details. The documentation from our website can also be downloaded locally from _documentation/tdenginedocs-en_ or _documentation/tdenginedocs-cn_.
+For user manual, system design and architecture, please refer to [TDengine Documentation](https://docs.tdengine.com) ([中文版](https://docs.taosdata.com))
 
 # Building
 
-At the moment, TDengine server only supports running on Linux systems. You can choose to [install from packages](https://www.taosdata.com/en/getting-started/#Install-from-Package) or build it from the source code. This quick guide is for installation from the source only.
+At the moment, TDengine server supports running on Linux, Windows, and macOS systems. You can choose to [install from packages](https://www.tdengine.com/getting-started/#Install-from-Package) or build it from the source code. This quick guide is for installation from the source only.
+
+We provide a few useful tools such as taosBenchmark (was named taosdemo) and taosdump. They were part of TDengine. By default, TDengine compiling does not include taosTools. You can use 'cmake .. -DBUILD_TOOLS=true' to make them be compiled with TDengine.
 
 To build TDengine, use [CMake](https://cmake.org/) 3.0.2 or higher versions in the project directory.
 
 ## Install build dependencies
 
-### Ubuntu 16.04 and above or Debian
+### Ubuntu 18.04 and above or Debian
 
 ```bash
 sudo apt-get install -y gcc cmake build-essential git libssl-dev
 ```
 
-### Ubuntu 14.04
-
-```bash
-sudo apt-get install -y gcc cmake3 build-essential git binutils-2.26
-export PATH=/usr/lib/binutils-2.26/bin:$PATH
-```
-
-To compile and package the JDBC driver source code, you should have a Java jdk-8 or higher and Apache Maven 2.7 or higher installed.
-
-To install openjdk-8:
-
-```bash
-sudo apt-get install -y openjdk-8-jdk
-```
-
-To install Apache Maven:
-
-```bash
-sudo apt-get install -y maven
-```
-
 #### Install build dependencies for taosTools
 
-We provide a few useful tools such as taosBenchmark (was named taosdemo) and taosdump. They were part of TDengine. From TDengine 2.4.0.0, taosBenchmark and taosdump were not released together with TDengine.
-By default, TDengine compiling does not include taosTools. You can use 'cmake .. -DBUILD_TOOLS=true' to make them be compiled with TDengine.
-
 To build the [taosTools](https://github.com/taosdata/taos-tools) on Ubuntu/Debian, the following packages need to be installed.
 
 ```bash
 sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-dev pkg-config
 ```
 
-### CentOS 7
+### CentOS 7.9
 
 ```bash
 sudo yum install epel-release
@@ -100,36 +71,12 @@ sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 
-To install openjdk-8:
-
-```bash
-sudo yum install -y java-1.8.0-openjdk
-```
-
-To install Apache Maven:
-
-```bash
-sudo yum install -y maven
-```
-
 ### CentOS 8 & Fedora
 
 ```bash
 sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 ```
 
-To install openjdk-8:
-
-```bash
-sudo dnf install -y java-1.8.0-openjdk
-```
-
-To install Apache Maven:
-
-```bash
-sudo dnf install -y maven
-```
-
 #### Install build dependencies for taosTools on CentOS
 
 To build the [taosTools](https://github.com/taosdata/taos-tools) on CentOS, the following packages need to be installed.
@@ -138,11 +85,11 @@ To build the [taosTools](https://github.com/taosdata/taos-tools) on CentOS, the
 sudo yum install zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
 ```
 
-Note: Since snappy lacks pkg-config support (refer to [link](https://github.com/google/snappy/pull/86)), it lead a cmake prompt libsnappy not found. But snappy will works well.
+Note: Since snappy lacks pkg-config support (refer to [link](https://github.com/google/snappy/pull/86)), it leads a cmake prompt libsnappy not found. But snappy still works well.
 
 ### Setup golang environment
 
-TDengine includes few components developed by Go language. Please refer to golang.org official documentation for golang environment setup.
+TDengine includes a few components like taosAdapter developed by Go language. Please refer to golang.org official documentation for golang environment setup.
 
 Please use version 1.14+. For the user in China, we recommend using a proxy to accelerate package downloading.
 
@@ -153,7 +100,7 @@ go env -w GOPROXY=https://goproxy.cn,direct
 
 ### Setup rust environment
 
-TDengine includees few compoments developed by Rust language. Please refer to rust-lang.org official documentation for rust environment setup.
+TDengine includes a few compoments developed by Rust language. Please refer to rust-lang.org official documentation for rust environment setup.
 
 ## Get the source codes
 
@@ -164,14 +111,9 @@ git clone https://github.com/taosdata/TDengine.git
 cd TDengine
 ```
 
-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
-git submodule update --init --recursive
-```
+The connectors for go & Grafana and some tools have been moved to separated repositories.
 
-You can modify the file ~/.gitconfig to use ssh protocol instead of https for better download speed. You need to upload ssh public key to GitHub first. Please refer to GitHub official documentation for detail.
+You can modify the file ~/.gitconfig to use ssh protocol instead of https for better download speed. You will need to upload ssh public key to GitHub first. Please refer to GitHub official documentation for detail.
 
 ```
 [url "git@github.com:"]
@@ -191,21 +133,13 @@ You can run the bash script `build.sh` to build both TDengine and taosTools incl
 It equals to execute following commands:
 
 ```bash
-git submodule update --init --recursive
 mkdir debug
 cd debug
 cmake .. -DBUILD_TOOLS=true
 make
 ```
 
-Note TDengine 2.3.x.0 and later use a component named 'taosAdapter' to play http daemon role by default instead of the http daemon embedded in the early version of TDengine. The taosAdapter is programmed by go language. If you pull TDengine source code to the latest from an existing codebase, please execute 'git submodule update --init --recursive' to pull taosAdapter source code. Please install go language version 1.14 or above for compiling taosAdapter. If you meet difficulties regarding 'go mod', especially you are from China, you can use a proxy to solve the problem.
-
-```
-go env -w GO111MODULE=on
-go env -w GOPROXY=https://goproxy.cn,direct
-```
-
-The embedded http daemon still be built from TDengine source code by default. Or you can use the following command to choose to build taosAdapter.
+Note TDengine 2.3.x.0 and later use a component named 'taosAdapter' to play http daemon role. If you pull TDengine source code to the latest from an existing codebase, please execute 'git submodule update --init --recursive' to pull taosAdapter source code, and use the following command to choose to build taosAdapter.
 
 ```
 cmake .. -DBUILD_HTTP=false
@@ -218,8 +152,8 @@ apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```
 
-TDengine build script can detect the host machine's architecture on X86-64, X86, arm64, arm32 and mips64 platform.
-You can also specify CPUTYPE option like aarch64 or aarch32 too if the detection result is not correct:
+TDengine build script can detect the host machine's architecture on X86-64, X86, arm64 platform.
+You can also specify CPUTYPE option like aarch64 too if the detection result is not correct:
 
 aarch64:
 
@@ -227,22 +161,10 @@ aarch64:
 cmake .. -DCPUTYPE=aarch64 && cmake --build .
 ```
 
-aarch32:
-
-```bash
-cmake .. -DCPUTYPE=aarch32 && cmake --build .
-```
-
-mips64:
-
-```bash
-cmake .. -DCPUTYPE=mips64 && cmake --build .
-```
-
 ### On Windows platform
 
 If you use the Visual Studio 2013, please open a command window by executing "cmd.exe".
-Please specify "amd64" for 64 bits Windows or specify "x86" is for 32 bits Windows when you execute vcvarsall.bat.
+Please specify "amd64" for 64 bits Windows or specify "x86" for 32 bits Windows when you execute vcvarsall.bat.
 
 ```cmd
 mkdir debug && cd debug
@@ -254,7 +176,7 @@ nmake
 If you use the Visual Studio 2019 or 2017:
 
 please open a command window by executing "cmd.exe".
-Please specify "x64" for 64 bits Windows or specify "x86" is for 32 bits Windows when you execute vcvarsall.bat.
+Please specify "x64" for 64 bits Windows or specify "x86" for 32 bits Windows when you execute vcvarsall.bat.
 
 ```cmd
 mkdir debug && cd debug
@@ -307,19 +229,6 @@ taos
 
 If TDengine shell connects the server successfully, welcome messages and version info are printed. Otherwise, an error message is shown.
 
-### Install TDengine by apt-get
-
-If you use Debian or Ubuntu system, you can use 'apt-get' command to install TDengine from official repository. Please use following commands to setup:
-
-```
-wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
-echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
-[Optional] echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
-sudo apt-get update
-apt-cache policy tdengine
-sudo apt-get install tdengine
-```
-
 ## On Windows platform
 
 After building successfully, TDengine can be installed by:
@@ -336,24 +245,6 @@ After building successfully, TDengine can be installed by:
 sudo make install
 ```
 
-To start the service after installation, config `.plist` file first, in a terminal, use:
-
-```bash
-sudo cp ../packaging/macOS/com.taosdata.tdengine.plist /Library/LaunchDaemons
-```
-
-To start the service, in a terminal, use:
-
-```bash
-sudo launchctl load /Library/LaunchDaemons/com.taosdata.tdengine.plist
-```
-
-To stop the service, in a terminal, use:
-
-```bash
-sudo launchctl unload /Library/LaunchDaemons/com.taosdata.tdengine.plist
-```
-
 ## Quick Run
 
 If you don't want to run TDengine as a service, you can run it in current shell. For example, to quickly start a TDengine server after building, run the command below in terminal: (We take Linux as an example, command on Windows will be `taosd.exe`)
@@ -394,36 +285,20 @@ Query OK, 2 row(s) in set (0.001700s)
 
 TDengine provides abundant developing tools for users to develop on TDengine. Follow the links below to find your desired connectors and relevant documentation.
 
-- [Java](https://www.taosdata.com/en/documentation/connector/java)
-- [C/C++](https://www.taosdata.com/en/documentation/connector#c-cpp)
-- [Python](https://www.taosdata.com/en/documentation/connector#python)
-- [Go](https://www.taosdata.com/en/documentation/connector#go)
-- [RESTful API](https://www.taosdata.com/en/documentation/connector#restful)
-- [Node.js](https://www.taosdata.com/en/documentation/connector#nodejs)
-- [Rust](https://www.taosdata.com/en/documentation/connector/rust)
-
-## Third Party Connectors
-
-The TDengine community has also kindly built some of their own connectors! Follow the links below to find the source code for them.
-
-- [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)
+- [Java](https://docs.taosdata.com/reference/connector/java/)
+- [C/C++](https://docs.taosdata.com/reference/connector/cpp/)
+- [Python](https://docs.taosdata.com/reference/connector/python/)
+- [Go](https://docs.taosdata.com/reference/connector/go/)
+- [Node.js](https://docs.taosdata.com/reference/connector/node/)
+- [Rust](https://docs.taosdata.com/reference/connector/rust/)
+- [C#](https://docs.taosdata.com/reference/connector/csharp/)
+- [RESTful API](https://docs.taosdata.com/reference/rest-api/)
 
 # 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](https://github.com/taosdata/TDengine/blob/develop/tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.
 
-# TDengine Roadmap
-
-- Support event-driven stream computing
-- Support user defined functions
-- Support MQTT connection
-- Support OPC connection
-- Support Hadoop, Spark connections
-- Support Tableau and other BI tools
-
 # Contribute to TDengine
 
 Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to the project.

build.sh

+#!/bin/bash
+
+if [ ! -d debug ]; then
+    mkdir debug || echo -e "failed to make directory for build"
+fi
+
+cd debug && cmake .. -DBUILD_TOOLS=true && make
+

cmake/cmake.define

@@ -115,9 +115,7 @@ ELSE ()
     ENDIF ()
 
     MESSAGE("System processor ID: ${CMAKE_SYSTEM_PROCESSOR}")
-    IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
-        ADD_DEFINITIONS("-D_TD_ARM_")
-    ELSE ()
+    IF (TD_INTEL_64 OR TD_INTEL_32)
         ADD_DEFINITIONS("-msse4.2")
         IF("${FMA_SUPPORT}" MATCHES "true")
             MESSAGE(STATUS "turn fma function support on")

cmake/cmake.install

-IF (TD_LINUX)
+IF (EXISTS /var/lib/taos/dnode/dnodeCfg.json)
+  INSTALL(CODE "MESSAGE(\"The default data directory /var/lib/taos contains old data of tdengine 2.x, please clear it before installing!\")")
+ELSEIF (EXISTS C:/TDengine/data/dnode/dnodeCfg.json)
+  INSTALL(CODE "MESSAGE(\"The default data directory C:/TDengine/data contains old data of tdengine 2.x, please clear it before installing!\")")
+ELSEIF (TD_LINUX)
   SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.sh")
   INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
   INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${PROJECT_BINARY_DIR} Linux ${TD_VER_NUMBER})")
@@ -10,7 +14,9 @@ ELSEIF (TD_WINDOWS)
   # INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/python DESTINATION connector)
   # INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/C\# DESTINATION connector)
   # INSTALL(DIRECTORY ${TD_SOURCE_DIR}/examples DESTINATION .)
-  INSTALL(FILES ${TD_SOURCE_DIR}/packaging/cfg/taos.cfg DESTINATION cfg)
+  INSTALL(CODE "IF (NOT EXISTS ${CMAKE_INSTALL_PREFIX}/cfg/taos.cfg)
+    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${TD_SOURCE_DIR}/packaging/cfg/taos.cfg ${CMAKE_INSTALL_PREFIX}/cfg/taos.cfg)
+  ENDIF ()")
   INSTALL(FILES ${TD_SOURCE_DIR}/include/client/taos.h DESTINATION include)
   INSTALL(FILES ${TD_SOURCE_DIR}/include/util/taoserror.h DESTINATION include)
   INSTALL(FILES ${TD_SOURCE_DIR}/include/libs/function/taosudf.h DESTINATION include)
@@ -20,6 +26,9 @@ ELSEIF (TD_WINDOWS)
   INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
   INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosd.exe DESTINATION .)
   INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/udfd.exe DESTINATION .)
+  IF (BUILD_TOOLS)
+    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosBenchmark.exe DESTINATION .)
+  ENDIF ()
 
   IF (TD_MVN_INSTALLED)
     INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.38-dist.jar DESTINATION connector/jdbc)

cmake/cmake.platform

@@ -85,26 +85,36 @@ IF ("${CPUTYPE}" STREQUAL "")
     MESSAGE(STATUS "The current platform is aarch32")
     SET(PLATFORM_ARCH_STR "arm")
     SET(TD_ARM_32 TRUE)
+    ADD_DEFINITIONS("-D_TD_ARM_")
+    ADD_DEFINITIONS("-D_TD_ARM_32")
   ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
     MESSAGE(STATUS "The current platform is aarch64")
     SET(PLATFORM_ARCH_STR "arm64")
     SET(TD_ARM_64 TRUE)
+    ADD_DEFINITIONS("-D_TD_ARM_")
+    ADD_DEFINITIONS("-D_TD_ARM_64")
   ENDIF ()
 ELSE ()
   # if generate ARM version:
   #   cmake -DCPUTYPE=aarch32 .. or cmake -DCPUTYPE=aarch64
-  IF (${CPUTYPE} MATCHES "aarch32")
+  IF (${CPUTYPE} MATCHES "aarch32" OR ${CPUTYPE} MATCHES "arm32")
     SET(PLATFORM_ARCH_STR "arm")
     MESSAGE(STATUS "input cpuType: aarch32")
+    ADD_DEFINITIONS("-D_TD_ARM_")
+    ADD_DEFINITIONS("-D_TD_ARM_32")
     SET(TD_ARM_32 TRUE)
-  ELSEIF (${CPUTYPE} MATCHES "aarch64")
+  ELSEIF (${CPUTYPE} MATCHES "aarch64" OR ${CPUTYPE} MATCHES "arm64")
     SET(PLATFORM_ARCH_STR "arm64")
     MESSAGE(STATUS "input cpuType: aarch64")
+    ADD_DEFINITIONS("-D_TD_ARM_")
+    ADD_DEFINITIONS("-D_TD_ARM_64")
     SET(TD_ARM_64 TRUE)
   ELSEIF (${CPUTYPE} MATCHES "mips64")
     SET(PLATFORM_ARCH_STR "mips")
     MESSAGE(STATUS "input cpuType: mips64")
     SET(TD_MIPS_64 TRUE)
+    ADD_DEFINITIONS("-D_TD_MIPS_")
+    ADD_DEFINITIONS("-D_TD_MIPS_64")
   ELSEIF (${CPUTYPE} MATCHES "x64")
     SET(PLATFORM_ARCH_STR "amd64")
     MESSAGE(STATUS "input cpuType: x64")

cmake/taosadapter_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
         GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG 766dcc4
+        GIT_TAG 3d21433
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 8a5e336
+        GIT_TAG 53a0103
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

cmake/taosws_CMakeLists.txt.in

 
 # taosws-rs
 ExternalProject_Add(taosws-rs
-        GIT_REPOSITORY https://github.com/taosdata/taosws-rs.git
-        GIT_TAG 648cc62
+        GIT_REPOSITORY https://github.com/taosdata/taos-connector-rust.git
+        GIT_TAG 7a54d21
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosws-rs"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/assets/tdengine.svg

+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 500 105" style="enable-background:new 0 0 1000 210;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#18499D;}
+	.st1{fill-rule:evenodd;clip-rule:evenodd;fill:#18499D;}
+</style>
+<g>
+	<path class="st0" d="M153.2,27.1h-16v49h-11.1v-49h-15.9v-9.7h43L153.2,27.1z"/>
+	<path class="st0" d="M180.6,17.4c17.1,0,28.5,4.9,28.5,29.4c0,22.7-11.4,29.4-28.5,29.4h-19V17.4H180.6z M180.1,66.5
+		c11.3,0,17.6-4.3,17.6-19.8c0-16.3-6.5-20-17.6-20h-7.4v39.8L180.1,66.5z"/>
+	<path class="st0" d="M259.4,55.3l-30,2c0.2,7.7,4,11.2,13.1,11.2c5.1-0.1,10.2-1.1,14.9-3.1V74c-2.7,1.6-9.3,3-16.8,3
+		c-13.9,0-21.9-5.2-21.9-23.7s8-23.7,21.9-23.7c15.8,0,19.1,9,19.1,19.7C259.8,51.3,259.7,53.3,259.4,55.3z M250,48.2
+		c0-5.7-1.2-10.5-9.3-10.5c-8.5,0-11,4.1-11.3,12L250,48.2z"/>
+	<path class="st0" d="M310.8,44.8v31.3h-10.6V47.8c0-6.4-1.4-9.4-7.9-9.4c-5.4,0-9.2,1.5-11.2,7.3v30.5h-10.6V30.4h10.6v5.8
+		c2.6-4.7,8-6.6,14.4-6.6C307.1,29.6,310.8,35.1,310.8,44.8z"/>
+	<path class="st0" d="M364.8,30.4v42.2c0,12.6-6.5,20.4-24.3,20.4c-4.1,0-8.3-0.4-12.4-1.1v-8.5c3.9,0.9,7.8,1.3,11.8,1.3
+		c10.1,0,14.4-3.3,14.4-12.5v-3.2c-2,4.5-5.7,7.2-14.1,7.2c-15,0-18.7-9.4-18.7-23.3c0-12.6,3.7-23.3,18.7-23.3
+		c8.6,0,12.4,3.1,14.1,7.5v-6.7H364.8z M354.7,52.8c0-9.2-2-15.1-11.9-15.1c-9.4,0-10.4,7.3-10.4,15.1c0,8.5,1.3,15.3,10.4,15.3
+		C352.7,68.2,354.7,62.6,354.7,52.8z"/>
+	<path class="st0" d="M377.3,17.6c0-5.2,1.3-5.7,6-5.7s6,0.5,6,5.7s-1.3,5.8-6,5.8S377.3,22.7,377.3,17.6z M378,30.4h10.6v45.7H378
+		L378,30.4z"/>
+	<path class="st0" d="M442,44.8v31.3h-10.5V47.8c0-6.4-1.4-9.4-7.9-9.4c-5.4,0-9.2,1.5-11.2,7.3v30.5h-10.6V30.4h10.6v5.8
+		c2.6-4.7,8-6.6,14.4-6.6C438.3,29.6,442,35.1,442,44.8z"/>
+	<path class="st0" d="M493.3,55.3l-30,2c0.3,7.7,4,11.2,13.1,11.2c5.1-0.1,10.2-1.1,14.9-3.1V74c-2.7,1.6-9.3,3-16.8,3
+		c-13.9,0-21.9-5.2-21.9-23.7s8-23.7,21.9-23.7c15.8,0,19.1,9,19.1,19.7C493.8,51.3,493.6,53.3,493.3,55.3z M483.9,48.2
+		c0-5.7-1.2-10.5-9.3-10.5c-8.5,0-11,4.1-11.3,12L483.9,48.2z"/>
+	<path class="st1" d="M48.8,11.8c3.1,0,5.6,2.5,5.6,5.6c0,3.1-2.5,5.6-5.6,5.6s-5.6-2.5-5.6-5.6c0,0,0,0,0,0
+		C43.3,14.3,45.7,11.8,48.8,11.8z M11.8,38.5c3.1,0,5.6,2.5,5.6,5.6c0,3.1-2.5,5.6-5.6,5.6s-5.6-2.5-5.6-5.6
+		C6.3,41,8.8,38.5,11.8,38.5z M26.3,82.1c3.1,0,5.6,2.5,5.6,5.6s-2.5,5.6-5.6,5.6c-3.1,0-5.6-2.5-5.6-5.6
+		C20.7,84.6,23.2,82.1,26.3,82.1z M71.3,82.1c3.1,0,5.6,2.5,5.6,5.6s-2.5,5.6-5.6,5.6s-5.6-2.5-5.6-5.6
+		C65.7,84.6,68.2,82.1,71.3,82.1z M57,44.9H40.6l-5,15.5l13.2,9.6L62,60.5L57,44.9L57,44.9z M41.1,43.6L46.8,26
+		c-0.4-0.1-0.9-0.2-1.3-0.4l-5.8,18h-19c0,0.2,0,0.3,0,0.5c0,0.3,0,0.6,0,0.8h18.5l-4.8,14.7l-15-10.9c-0.2,0.4-0.5,0.7-0.8,1.1
+		l12.8,9.3l0,0l2.6,1.9l-0.9,2.5l0,0l-5,15.5c0.4,0.1,0.9,0.2,1.3,0.4l5.7-17.5l12.5,9.1L32.9,81.7c0.3,0.3,0.6,0.7,0.8,1l15.1-11
+		l15.1,11c0.2-0.4,0.5-0.7,0.8-1L49.9,70.9l12.5-9.1l0.6,1.7l0,0l5.2,15.9c0.4-0.2,0.8-0.3,1.3-0.4l-5.8-18l2.6-1.9L79,49.8
+		c-0.3-0.3-0.5-0.7-0.8-1.1l-12.4,9L65.4,58l-2.3,1.6l-4.8-14.7h18.5c0-0.3,0-0.6,0-0.9c0-0.2,0-0.3,0-0.5h-19l-5.8-18
+		c-0.4,0.2-0.8,0.3-1.3,0.4l5.7,17.6L41.1,43.6z M18.9,38.6l22.5-16.4c0.2,0.4,0.5,0.7,0.8,1L19.6,39.7C19.4,39.3,19.1,39,18.9,38.6
+		L18.9,38.6z M22.9,79.4l-8.7-26.8c0.4-0.1,0.8-0.3,1.2-0.4L24.2,79C23.7,79.1,23.3,79.3,22.9,79.4L22.9,79.4z M62.5,88H35.2
+		c0-0.1,0-0.2,0-0.4c0-0.3,0-0.6,0-1h27.3c0,0.3,0,0.6,0,1C62.4,87.8,62.4,87.9,62.5,88L62.5,88z M83.5,52.7l-8.7,26.8
+		c-0.4-0.2-0.8-0.3-1.2-0.4l8.7-26.8C82.6,52.4,83,52.6,83.5,52.7z M56.3,22.2l22.5,16.4c-0.3,0.3-0.5,0.7-0.7,1.1L55.4,23.3
+		C55.7,22.9,56,22.6,56.3,22.2z M85.8,38.5c3.1,0,5.6,2.5,5.6,5.6c0,3.1-2.5,5.6-5.6,5.6s-5.6-2.5-5.6-5.6
+		C80.2,41,82.7,38.5,85.8,38.5z"/>
+</g>
+</svg>

docs/en/05-get-started/01-docker.md

+---
+sidebar_label: Docker
+title: 通过 Docker 快速体验 TDengine
+---
+:::info
+如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
+:::
+
+本节首先介绍如何通过 Docker 快速体验 TDengine，然后介绍如何在 Docker 环境下体验 TDengine 的写入和查询功能。
+
+## 启动 TDengine
+
+如果已经安装了 docker， 只需执行下面的命令。
+
+```shell
+docker run -d -p 6030:6030 -p 6041/6041 -p 6043-6049/6043-6049 -p 6043-6049:6043-6049/udp tdengine/tdengine
+```
+
+注意：TDengine 3.0 服务端仅使用 6030 TCP 端口。6041 为 taosAdapter 所使用提供 REST 服务端口。6043-6049 为 taosAdapter 提供第三方应用接入所使用端口，可根据需要选择是否打开。
+
+确定该容器已经启动并且在正常运行
+
+```shell
+docker ps
+```
+
+进入该容器并执行 bash
+
+```shell
+docker exec -it <container name> bash
+```
+
+然后就可以执行相关的 Linux 命令操作和访问 TDengine
+
+## 运行 TDengine CLI
+
+进入容器，执行 taos 
+
+```
+$ taos
+Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
+Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
+
+Server is Community Edition.
+
+taos> 
+
+```
+
+## 写入数据
+
+可以使用 TDengine 的自带工具 taosBenchmark 快速体验 TDengine 的写入。
+
+进入容器，启动 taosBenchmark：
+
+   ```bash
+   $ taosBenchmark
+   
+   ```
+
+   该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "San Francisco" 或者 "Los Angeles"等城市名称。
+
+   这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能。
+
+   taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [taosBenchmark 参考手册](../../reference/taosbenchmark)。
+
+## 体验查询
+
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。。
+
+查询超级表下记录总条数：
+
+```sql
+taos> select count(*) from test.meters;
+```
+
+查询 1 亿条记录的平均值、最大值、最小值等：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters;
+```
+
+查询 location="San Francisco" 的记录总条数：
+
+```sql
+taos> select count(*) from test.meters where location="San Francisco";
+```
+
+查询 groupId=10 的所有记录的平均值、最大值、最小值等：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
+```
+
+对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
+```
+
+## 其它
+
+更多关于在 Docker 环境下使用 TDengine 的细节，请参考 [在 Docker 下使用 TDengine](../../reference/docker)

docs/en/05-get-started/03-package.md

+---
+sidebar_label: 安装包
+title: 使用安装包立即开始
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+:::info
+如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
+
+:::
+
+TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统，rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包，也支持通过 `apt-get` 工具从线上进行安装。
+
+## 安装
+
+<Tabs>
+<TabItem value="apt-get" label="apt-get">
+可以使用 apt-get 工具从官方仓库安装。
+
+**安装包仓库**
+
+```bash
+wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
+echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
+```
+
+如果安装 Beta 版需要安装包仓库
+
+```bash
+echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
+```
+
+**使用 apt-get 命令安装**
+
+```bash
+sudo apt-get update
+apt-cache policy tdengine
+sudo apt-get install tdengine
+```
+
+:::tip
+apt-get 方式只适用于 Debian 或 Ubuntu 系统
+::::
+</TabItem>
+<TabItem label="Deb 安装" value="debinst">
+
+1、从官网下载获得 deb 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.deb；
+2、进入到 TDengine-server-3.0.0.0-Linux-x64.deb 安装包所在目录，执行如下的安装命令：
+
+```bash
+sudo dpkg -i TDengine-server-3.0.0.0-Linux-x64.deb
+```
+
+</TabItem>
+
+<TabItem label="RPM 安装" value="rpminst">
+
+1、从官网下载获得 rpm 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.rpm；
+2、进入到 TDengine-server-3.0.0.0-Linux-x64.rpm 安装包所在目录，执行如下的安装命令：
+
+```bash
+sudo rpm -ivh TDengine-server-3.0.0.0-Linux-x64.rpm
+```
+
+</TabItem>
+
+<TabItem label="tar.gz 安装" value="tarinst">
+
+1、从官网下载获得 tar.gz 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.tar.gz；
+2、进入到 TDengine-server-3.0.0.0-Linux-x64.tar.gz 安装包所在目录，先解压文件后，进入子目录，执行其中的 install.sh 安装脚本：
+
+```bash
+tar -zxvf TDengine-server-3.0.0.0-Linux-x64.tar.gz
+```
+
+解压后进入相应路径，执行
+
+```bash
+sudo ./install.sh
+```
+
+:::info
+install.sh 安装脚本在执行过程中，会通过命令行交互界面询问一些配置信息。如果希望采取无交互安装方式，那么可以用 -e no 参数来执行 install.sh 脚本。运行 `./install.sh -h` 指令可以查看所有参数的详细说明信息。
+
+:::
+
+</TabItem>
+</Tabs>
+
+:::note
+当安装第一个节点时，出现 Enter FQDN：提示的时候，不需要输入任何内容。只有当安装第二个或以后更多的节点时，才需要输入已有集群中任何一个可用节点的 FQDN，支持该新节点加入集群。当然也可以不输入，而是在新节点启动前，配置到新节点的配置文件中。
+
+:::
+
+## 启动
+
+安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
+
+```bash
+systemctl start taosd
+```
+
+检查服务是否正常工作：
+
+```bash
+systemctl status taosd
+```
+
+如果服务进程处于活动状态，则 status 指令会显示如下的相关信息：
+
+```
+Active: active (running)
+```
+
+如果后台服务进程处于停止状态，则 status 指令会显示如下的相关信息：
+
+```
+Active: inactive (dead)
+```
+
+如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
+
+systemctl 命令汇总：
+
+- 启动服务进程：`systemctl start taosd`
+
+- 停止服务进程：`systemctl stop taosd`
+
+- 重启服务进程：`systemctl restart taosd`
+
+- 查看服务状态：`systemctl status taosd`
+
+:::info
+
+- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
+- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
+- 如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
+
+:::
+
+## TDengine 命令行 (CLI)
+
+为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
+
+```bash
+taos
+```
+
+如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
+
+```cmd
+taos>
+```
+
+在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
+
+```sql
+create database demo;
+use demo;
+create table t (ts timestamp, speed int);
+insert into t values ('2019-07-15 00:00:00', 10);
+insert into t values ('2019-07-15 01:00:00', 20);
+select * from t;
+           ts            |    speed    |
+========================================
+ 2019-07-15 00:00:00.000 |          10 |
+ 2019-07-15 01:00:00.000 |          20 |
+Query OK, 2 row(s) in set (0.003128s)
+```
+
+除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../../reference/taos-shell/)
+
+## 使用 taosBenchmark 体验写入速度
+
+启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
+
+```bash
+taosBenchmark
+```
+
+该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
+
+这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
+
+taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
+
+## 使用 TDengine CLI 体验查询速度
+
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
+
+查询超级表下记录总条数：
+
+```sql
+taos> select count(*) from test.meters;
+```
+
+查询 1 亿条记录的平均值、最大值、最小值等：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters;
+```
+
+查询 location="California.SanFrancisco" 的记录总条数：
+
+```sql
+taos> select count(*) from test.meters where location="California.SanFrancisco";
+```
+
+查询 groupId=10 的所有记录的平均值、最大值、最小值等：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
+```
+
+对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
+```

docs/en/05-get-started/_apt_get_install.mdx

-`apt-get` can be used to install TDengine from official package repository. 
+可以使用 apt-get 工具从官方仓库安装。
 
-**Package Repository**
+**安装包仓库**
 
 ```
 wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
 ```
 
-The repository required for installing beta versions can be configured as below:
+如果安装 Beta 版需要安装包仓库
 
 ```
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
 ```
 
-**Install With apt-get**
+**使用 apt-get 命令安装**
 
 ```
 sudo apt-get update
@@ -22,5 +22,5 @@ sudo apt-get install tdengine
 ```
 
 :::tip
-`apt-get` can only be used on Debian or Ubuntu Linux.
+apt-get 方式只适用于 Debian 或 Ubuntu 系统
 ::::

docs/en/05-get-started/_category_.yml

-label: Get Started
+label: 立即开始

docs/en/05-get-started/_pkg_install.mdx

 import PkgList from "/components/PkgList";
 
-It's very easy to install TDengine and would take you only a few minutes from downloading to finishing installation.
+TDengine 的安装非常简单，从下载到安装成功仅仅只要几秒钟。
 
-For the convenience of users, from version 2.4.0.10, the standard server side installation package includes `taos`, `taosd`, `taosAdapter`, `taosBenchmark` and sample code. If only the `taosd` server and C/C++ connector are required, you can also choose to download the lite package.
+为方便使用，从 2.4.0.10 开始，标准的服务端安装包包含了 taos、taosd、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码；如果您只需要用到服务端程序和客户端连接的 C/C++ 语言支持，也可以仅下载 lite 版本的安装包。
 
-Three kinds of packages are provided, tar.gz, rpm and deb. Especially the tar.gz package is provided for the convenience of enterprise customers on different kinds of operating systems, it includes `taosdump`  and TDinsight installation script which are normally only provided in taos-tools rpm and deb packages.
+在安装包格式上，我们提供 tar.gz, rpm 和 deb 格式，为企业客户提供 tar.gz 格式安装包，以方便在特定操作系统上使用。需要注意的是，rpm 和 deb 包不含 taosdump、taosBenchmark 和 TDinsight 安装脚本，这些工具需要通过安装 taosTool 包获得。
 
-Between two major release versions, some beta versions may be delivered for users to try some new features.
+发布版本包括稳定版和 Beta 版，Beta 版含有更多新功能。正式上线或测试建议安装稳定版。您可以根据需要选择下载：
 
 <PkgList type={0}/>
 
-For the details please refer to [Install and Uninstall](/operation/pkg-install)。
-
-To see the details of versions, please refer to [Download List](https://tdengine.com/all-downloads) and [Release Notes](https://github.com/taosdata/TDengine/releases).
+具体的安装方法，请参见[安装包的安装和卸载](/operation/pkg-install)。
 
+下载其他组件、最新 Beta 版及之前版本的安装包，请点击[这里](https://www.taosdata.com/all-downloads)
 
+查看 Release Notes, 请点击[这里](https://github.com/taosdata/TDengine/releases) 

docs/en/05-get-started/index.md

 ---
-title: Get Started
-description: 'Install TDengine from Docker image, apt-get or package, and run TDengine CLI and taosBenchmark to experience the features'
+title: 立即开始
+description: '快速设置 TDengine 环境并体验其高效写入和查询'
 ---
 
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import PkgInstall from "./\_pkg_install.mdx";
-import AptGetInstall from "./\_apt_get_install.mdx";
+TDengine 完整的软件包包括服务端（taosd）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、应用驱动（taosc）、命令行程序 (CLI，taos) 和一些工具软件。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](/reference/taosadapter) 提供 [RESTful 接口](/reference/rest-api)。
 
-## Quick Install
+本章主要介绍如何利用 Docker 或者安装包快速设置 TDengine 环境并体验其高效写入和查询。
 
-The full package of TDengine includes the server(taosd), taosAdapter for connecting with third-party systems and providing a RESTful interface, client driver(taosc), command-line program(CLI, taos) and some tools. For the current version, the server taosd and taosAdapter can only be installed and run on Linux systems. In the future taosd and taosAdapter will also be supported on Windows, macOS and other systems. The client driver taosc and TDengine CLI can be installed and run on Windows or Linux. In addition to connectors for multiple languages, TDengine also provides a [RESTful interface](/reference/rest-api) through [taosAdapter](/reference/taosadapter). Prior to version 2.4.0.0, taosAdapter did not exist and the RESTful interface was provided by the built-in HTTP service of taosd.
+```mdx-code-block
+import DocCardList from '@theme/DocCardList';
+import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
 
-TDengine supports X64/ARM64/MIPS64/Alpha64 hardware platforms, and will support ARM32, RISC-V and other CPU architectures in the future.
-
-<Tabs defaultValue="apt-get">
+<DocCardList items={useCurrentSidebarCategory().items}/>
+```
\ No newline at end of file
-<TabItem value="docker" label="Docker">
-If docker is already installed on your computer, execute the following command:
-
-```shell
-docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengine
-```
-
-Make sure the container is running
-
-```shell
-docker ps
-```
-
-Enter into container and execute bash
-
-```shell
-docker exec -it <container name> bash
-```
-
-Then you can execute the Linux commands and access TDengine.
-
-For detailed steps, please visit [Experience TDengine via Docker](/train-faq/docker)。
-
-:::info
-Starting from 2.4.0.10，besides taosd，TDengine docker image includes: taos，taosAdapter，taosdump，taosBenchmark，TDinsight, scripts and sample code. Once the TDengine container is started，it will start both taosAdapter and taosd automatically to support RESTful interface.
-
-:::
-
-</TabItem>
-<TabItem value="apt-get" label="apt-get">
-<AptGetInstall />
-</TabItem>
-<TabItem value="pkg" label="Package">
-<PkgInstall />
-</TabItem>
-<TabItem value="src" label="Source Code">
-
-If you like to check the source code, build the package by yourself or contribute to the project, please check [TDengine GitHub Repository](https://github.com/taosdata/TDengine)
-
-</TabItem>
-</Tabs>
-
-## Quick Launch
-
-After installation, you can launch the TDengine service by the 'systemctl' command to start 'taosd'.
-
-```bash
-systemctl start taosd
-```
-
-Check if taosd is running：
-
-```bash
-systemctl status taosd
-```
-
-If everything is fine, you can run TDengine command-line interface `taos` to access TDengine and test it out yourself.
-
-:::info
-
-- systemctl requires _root_ privileges，if you are not _root_ ，please add sudo before the command.
-- To get feedback and keep improving the product, TDengine is collecting some basic usage information, but you can turn it off by setting telemetryReporting to 0 in configuration file taos.cfg. 
-- TDengine uses FQDN (usually hostname）as the ID for a node. To make the system work, you need to configure the FQDN for the server running taosd, and configure the DNS service or hosts file on the the machine where the application or TDengine CLI runs to ensure that the FQDN can be resolved.     
-- `systemctl stop taosd` won't stop the server right away, it will wait until all the data in memory are flushed to disk. It may takes time depending on the cache size.
-
-TDengine supports the installation on system which runs [`systemd`](https://en.wikipedia.org/wiki/Systemd) for process management，use `which systemctl` to check if the system has `systemd` installed:
-
-```bash
-which systemctl
-```
-
-If the system does not have `systemd`，you can start TDengine manually by executing `/usr/local/taos/bin/taosd`
-
-:::note
-
-## Command Line Interface
-
-To manage the TDengine running instance，or execute ad-hoc queries, TDengine provides a Command Line Interface (hereinafter referred to as TDengine CLI) taos. To enter into the interactive CLI，execute `taos` on a Linux terminal where TDengine is installed.
-
-```bash
-taos
-```
-
-If it connects to the TDengine server successfully, it will print out the version and welcome message. If it fails, it will print out the error message, please check [FAQ](/train-faq/faq) for trouble shooting connection issue. TDengine CLI's prompt is：
-
-```cmd
-taos>
-```
-
-Inside TDengine CLI，you can execute SQL commands to create/drop database/table, and run queries. The SQL command must be ended with a semicolon. For example:
-
-```sql
-create database demo;
-use demo;
-create table t (ts timestamp, speed int);
-insert into t values ('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
-select * from t;
-           ts            |    speed    |
-========================================
- 2019-07-15 00:00:00.000 |          10 |
- 2019-07-15 01:00:00.000 |          20 |
-Query OK, 2 row(s) in set (0.003128s)
-```
-
-Besides executing SQL commands, system administrators can check running status, add/drop user accounts and manage the running instances. TDengine CLI with client driver can be installed and run on either Linux or Windows machines. For more details on CLI, please [check here](../reference/taos-shell/).
-
-## Experience the blazing fast speed
-
-After TDengine server is running，execute `taosBenchmark` (previously named taosdemo) from a Linux terminal：
-
-```bash
-taosBenchmark
-```
-
-This command will create a super table "meters" under database "test". Under "meters", 10000 tables are created with names from "d0" to "d9999". Each table has 10000 rows and each row has four columns (ts, current, voltage, phase). Time stamp is starting from "2017-07-14 10:40:00 000" to "2017-07-14 10:40:09 999". Each table has tags "location" and "groupId". groupId is set 1 to 10 randomly, and location is set to "California.SanFrancisco" or "California.SanDiego".
-
-This command will insert 100 million rows into the database quickly. Time to insert depends on the hardware configuration, it only takes a dozen seconds for a regular PC server.            
-
-taosBenchmark provides command-line options and a configuration file to customize the scenarios, like number of tables, number of rows per table, number of columns and more. Please execute `taosBenchmark --help` to list them. For details on running taosBenchmark, please check [reference for taosBenchmark](/reference/taosbenchmark)
-
-## Experience query speed
-           
-After using taosBenchmark to insert a number of rows data, you can execute queries from TDengine CLI to experience the lightning fast query speed.
-
-query the total number of rows under super table "meters"：
-
-```sql
-taos> select count(*) from test.meters;
-```
-
-query the average, maximum, minimum of 100 million rows:
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters;
-```
-
-query the total number of rows with location="California.SanFrancisco":
-
-```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
-```
-
-query the average, maximum, minimum of all rows with groupId=10:
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
-```
-
-query the average, maximum, minimum for table d10 in 10 seconds time interval：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```

docs/en/07-develop/03-insert-data/02-influxdb-line.mdx

@@ -55,9 +55,6 @@ For more details please refer to [InfluxDB Line Protocol](https://docs.influxdat
   <TabItem label="Go" value="go">
     <GoLine />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustLine />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeLine />
   </TabItem>

docs/en/07-develop/03-insert-data/03-opentsdb-telnet.mdx

@@ -46,9 +46,6 @@ Please refer to [OpenTSDB Telnet API](http://opentsdb.net/docs/build/html/api_te
   <TabItem label="Go" value="go">
     <GoTelnet />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustTelnet />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeTelnet />
   </TabItem>

docs/en/07-develop/03-insert-data/04-opentsdb-json.mdx

@@ -63,9 +63,6 @@ Please refer to [OpenTSDB HTTP API](http://opentsdb.net/docs/build/html/api_http
   <TabItem label="Go" value="go">
     <GoJson />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustJson />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeJson />
   </TabItem>

docs/en/07-develop/03-insert-data/_rust_line.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/influxdb_line_example.rs}}
 ```

docs/en/07-develop/03-insert-data/_rust_opts_json.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/opentsdb_json_example.rs}}
 ```

docs/en/07-develop/03-insert-data/_rust_opts_telnet.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/opentsdb_telnet_example.rs}}
 ```

docs/en/14-reference/03-connector/03-connector.mdx

@@ -17,7 +17,6 @@ Currently, TDengine's native interface connectors can support platforms such as
 | **X86 64bit** | **Win32** | ● | ● | ● | ● | ○ | ○ | ● |
 | **X86 32bit** | **Win32** | ○ | ○ | ○ | ○ | ○ | ○ | ● |
 | **ARM64** | **Linux** | ● | ● | ● | ● | ○ | ○ | ● |
-| **ARM32** | **Linux** | ● | ● | ● | ● | ○ | ○ | ● |
 | **MIPS** | **Linux** | ○ | ○ | ○ | ○ | ○ | ○ | ○ |
 
 Where ● means the official test verification passed, ○ means the unofficial test verification passed, -- means no assurance.

docs/en/14-reference/08-taos-shell.md

@@ -47,27 +47,28 @@ If the displayed content is followed by `...` you can use this command to change
 
 You can change the behavior of TDengine CLI by specifying command-line parameters. The following parameters are commonly used.
 
-- -h, --host=HOST: FQDN of the server where the TDengine server is to be connected. Default is to connect to the local service
-- -P, --port=PORT: Specify the port number to be used by the server. Default is `6030`
-- -u, --user=USER: the user name to use when connecting. Default is `root`
-- -p, --password=PASSWORD: the password to use when connecting to the server. Default is `taosdata`
+- -h HOST: FQDN of the server where the TDengine server is to be connected. Default is to connect to the local service
+- -P PORT: Specify the port number to be used by the server. Default is `6030`
+- -u USER: the user name to use when connecting. Default is `root`
+- -p PASSWORD: the password to use when connecting to the server. Default is `taosdata`
 - -?, --help: print out all command-line arguments 
 
 And many more parameters.
 
-- -c, --config-dir: Specify the directory where configuration file exists. The default is `/etc/taos`, and the default name of the configuration file in this directory is `taos.cfg`
-- -C, --dump-config: Print the configuration parameters of `taos.cfg` in the default directory or specified by -c
-- -d, --database=DATABASE: Specify the database to use when connecting to the server
-- -D, --directory=DIRECTORY: Import the SQL script file in the specified path
-- -f, --file=FILE: Execute the SQL script file in non-interactive mode
-- -k, --check=CHECK: Specify the table to be checked
-- -l, --pktlen=PKTLEN: Test package size to be used for network testing
-- -n, --netrole=NETROLE: test scope for network connection test, default is `startup`. The value can be `client`, `server`, `rpc`, `startup`, `sync`, `speed`, or `fqdn`.
-- -r, --raw-time: output the timestamp format as unsigned 64-bits integer (uint64_t in C language)
-- -s, --commands=COMMAND: execute SQL commands in non-interactive mode
-- -S, --pkttype=PKTTYPE: Specify the packet type used for network testing. The default is TCP, can be specified as either TCP or UDP when `speed` is specified to `netrole` parameter
-- -T, --thread=THREADNUM: The number of threads to import data in multi-threaded mode
-- -s, --commands: Run TDengine CLI commands without entering the terminal
+- -a AUTHSTR: The auth string to use when connecting to the server
+- -A: Generate auth string from password
+- -c CONFIGDIR: Specify the directory where configuration file exists. The default is `/etc/taos`, and the default name of the configuration file in this directory is `taos.cfg`
+- -C: Print the configuration parameters of `taos.cfg` in the default directory or specified by -c
+- -d DATABASE: Specify the database to use when connecting to the server
+- -f FILE: Execute the SQL script file in non-interactive mode
+- -k: Check the service status, 0: unavailable，1: network ok，2: service ok，3: service degraded，4: exiting
+- -l PKTLEN: Test package length to be used for network testing
+- -n NETROLE: test scope for network connection test, default is `client`. The value can be `client`, `server`
+- -N PKTNUM: Test package numbers to be used for network testing
+- -r: output the timestamp format as unsigned 64-bits integer (uint64_t in C language)
+- -s COMMAND: execute SQL commands in non-interactive mode
+- -t: Check the details of the service status，status same as -k
+- -w DISPLAYWIDTH: 客户端列显示宽度
 - -z, --timezone=TIMEZONE: Specify time zone. Default is the value of current configuration file
 - -V, --version: Print out the current version number
 

docs/en/14-reference/09-support-platform/index.md

@@ -5,12 +5,11 @@ description: "List of platforms supported by TDengine server, client, and connec
 
 ## List of supported platforms for TDengine server
 
-|              | **CentOS 7/8** | **Ubuntu 16/18/20** | **Other Linux** |
-| ------------ | -------------- | ------------------- | --------------- |
-| X64          | ●              | ●                   |                 |
-| MIPS64       |                |                     | ●               |
-| ARM64        |                | ○                   | ○               |
-| Alpha64      |                |                     | ○               |
+|                    | **Windows 10/11** | **CentOS 7.9/8** | **Ubuntu 18/20** | **Other Linux** | **UOS** | **Kylin** | **Ningsi V60/V80** | **HUAWEI EulerOS** |
+| ------------------ | ----------------- | ---------------- | ---------------- | --------------- | ------- | --------- | ------------------ | ------------------ |
+| X64                | ●                 | ●                | ●                |                 | ●       | ●         | ●                  |                    |
+| Raspberry Pi ARM64 |                   |                  |                  | ●               |         |           |                    |                    |
+| HUAWEI cloud ARM64 |                   |                  |                  |                 |         |           |                    | ●                  |
 
 Note: ● means officially tested and verified, ○ means unofficially tested and verified.
 
@@ -20,15 +19,15 @@ TDengine's connector can support a wide range of platforms, including X64/X86/AR
 
 The comparison matrix is as follows.
 
-| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **ARM32** | **MIPS**  | **Alpha** |
-| ----------- | ------------- | --------- | --------- | ------------- | --------- | --------- | --------- | --------- |
-| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux** | **Linux** | **Linux** |
-| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●         | ●         | ●         |
-| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●         | ●         | ●         |
-| **Python**  | ●             | ●         | ●         | ○             | ●         | ●         | ●         | --        |
-| **Go**      | ●             | ●         | ●         | ○             | ●         | ●         | ○         | --        |
-| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ●         | ○         | --        |
-| **C#**      | ●             | ●         | ○         | ○             | ○         | ○         | ○         | --        |
-| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●         | ●         | ●         |
+| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **MIPS**  | **Alpha** |
+| ----------- | ------------- | --------- | --------- | ------------- | --------- | --------- | --------- |
+| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux** | **Linux** |
+| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●         | ●         |
+| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●         | ●         |
+| **Python**  | ●             | ●         | ●         | ○             | ●         | ●         | --        |
+| **Go**      | ●             | ●         | ●         | ○             | ●         | ○         | --        |
+| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ○         | --        |
+| **C#**      | ●             | ●         | ○         | ○             | ○         | ○         | --        |
+| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●         | ●         |
 
 Note: ● means the official test is verified, ○ means the unofficial test is verified, -- means not verified.

docs/en/14-reference/12-directory.md

@@ -25,7 +25,6 @@ All executable files of TDengine are in the _/usr/local/taos/bin_ directory by d
 - _taosBenchmark_: TDengine testing tool
 - _remove.sh_: script to uninstall TDengine, please execute it carefully, link to the **rmtaos** command in the /usr/bin directory. Will remove the TDengine installation directory `/usr/local/taos`, but will keep `/etc/taos`, `/var/lib/taos`, `/var/log/taos`
 - _taosadapter_: server-side executable that provides RESTful services and accepts writing requests from a variety of other softwares
-- _tarbitrator_: provides arbitration for two-node cluster deployments
 - _TDinsight.sh_: script to download TDinsight and install it
 - _set_core.sh_: script for setting up the system to generate core dump files for easy debugging
 - _taosd-dump-cfg.gdb_: script to facilitate debugging of taosd's gdb execution.

docs/en/14-reference/13-schemaless/13-schemaless.md

@@ -3,7 +3,7 @@ title: Schemaless Writing
 description: "The Schemaless write method eliminates the need to create super tables/sub tables in advance and automatically creates the storage structure corresponding to the data, as it is written to the interface."
 ---
 
-In IoT applications, data is collected for many purposes such as intelligent control, business analysis, device monitoring and so on. Due to changes in business or functional requirements or changes in device hardware, the application logic and even the data collected may change. To provide the flexibility needed in such cases and in a rapidly changing IoT landscape, TDengine starting from version 2.2.0.0, provides a series of interfaces for the schemaless writing method. These interfaces eliminate the need to create super tables and subtables in advance by automatically creating the storage structure corresponding to the data as the data is written to the interface. When necessary, schemaless writing will automatically add the required columns to ensure that the data written by the user is stored correctly.
+In IoT applications, data is collected for many purposes such as intelligent control, business analysis, device monitoring and so on. Due to changes in business or functional requirements or changes in device hardware, the application logic and even the data collected may change. To provide the flexibility needed in such cases and in a rapidly changing IoT landscape, TDengine provides a series of interfaces for the schemaless writing method. These interfaces eliminate the need to create super tables and subtables in advance by automatically creating the storage structure corresponding to the data as the data is written to the interface. When necessary, schemaless writing will automatically add the required columns to ensure that the data written by the user is stored correctly.
 
 The schemaless writing method creates super tables and their corresponding subtables. These are completely indistinguishable from the super tables and subtables created directly via SQL. You can write data directly to them via SQL statements. Note that the names of tables created by schemaless writing are based on fixed mapping rules for tag values, so they are not explicitly ideographic and they lack readability.
 
@@ -39,10 +39,10 @@ In the schemaless writing data line protocol, each data item in the field_set ne
 | -------- | -------- | ------------ | -------------- |
 | 1 | none or f64 | double | 8 |
 | 2 | f32 | float | 4 |
-| 3 | i8 | TinyInt | 1 |
-| 4 | i16 | SmallInt | 2 |
-| 5 | i32 | Int | 4 |
-| 6 | i64 or i | Bigint | 8 |
+| 3 | i8/u8 | TinyInt/UTinyInt | 1 |
+| 4 | i16/u16 | SmallInt/USmallInt | 2 |
+| 5 | i32/u32 | Int/UInt | 4 |
+| 6 | i64/i/u64/u | Bigint/Bigint/UBigint/UBigint | 8 |
 
 - `t`, `T`, `true`, `True`, `TRUE`, `f`, `F`, `false`, and `False` will be handled directly as BOOL types.
 
@@ -72,11 +72,11 @@ If the subtable obtained by the parse line protocol does not exist, Schemaless c
 4. If the specified tag or regular column in the data row does not exist, the corresponding tag or regular column is added to the super table (only incremental).
 5. If there are some tag columns or regular columns in the super table that are not specified to take values in a data row, then the values of these columns are set to NULL.
 6. For BINARY or NCHAR columns, if the length of the value provided in a data row exceeds the column type limit, the maximum length of characters allowed to be stored in the column is automatically increased (only incremented and not decremented) to ensure complete preservation of the data.
-7. If the specified data subtable already exists, and the specified tag column takes a value different from the saved value this time, the value in the latest data row overwrites the old tag column take value.
-8. Errors encountered throughout the processing will interrupt the writing process and return an error code.
+7. Errors encountered throughout the processing will interrupt the writing process and return an error code.
+8. In order to improve the efficiency of writing, it is assumed by default that the order of the fields in the same Super is the same (the first data contains all fields, and the following data is in this order). If the order is different, the parameter smlDataFormat needs to be configured to be false. Otherwise, the data is written in the same order, and the data in the library will be abnormal.
 
 :::tip
-All processing logic of schemaless will still follow TDengine's underlying restrictions on data structures, such as the total length of each row of data cannot exceed 48k bytes. See [TAOS SQL Boundary Limits](/taos-sql/limit) for specific constraints in this area.
+All processing logic of schemaless will still follow TDengine's underlying restrictions on data structures, such as the total length of each row of data cannot exceed 16k bytes. See [TAOS SQL Boundary Limits](/taos-sql/limit) for specific constraints in this area.
 :::
 
 ## Time resolution recognition

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

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

docs/examples/go/connect/cgoexample/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"database/sql"
 	"fmt"
+	"log"
 
 	_ "github.com/taosdata/driver-go/v3/taosSql"
 )
@@ -11,7 +12,7 @@ func main() {
 	var taosDSN = "root:taosdata@tcp(localhost:6030)/"
 	taos, err := sql.Open("taosSql", taosDSN)
 	if err != nil {
-		fmt.Println("failed to connect TDengine, err:", err)
+		log.Fatalln("failed to connect TDengine, err:", err)
 		return
 	}
 	fmt.Println("Connected")

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

@@ -3,6 +3,7 @@ package main
 import (
 	"database/sql"
 	"fmt"
+	"log"
 
 	_ "github.com/taosdata/driver-go/v3/taosRestful"
 )
@@ -11,7 +12,7 @@ func main() {
 	var taosDSN = "root:taosdata@http(localhost:6041)/"
 	taos, err := sql.Open("taosRestful", taosDSN)
 	if err != nil {
-		fmt.Println("failed to connect TDengine, err:", err)
+		log.Fatalln("failed to connect TDengine, err:", err)
 		return
 	}
 	fmt.Println("Connected")

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

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

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

 package main
 
 import (
-	"fmt"
+	"log"
 
 	"github.com/taosdata/driver-go/v3/af"
 )
@@ -20,7 +20,7 @@ func prepareDatabase(conn *af.Connector) {
 func main() {
 	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
 	if err != nil {
-		fmt.Println("fail to connect, err:", err)
+		log.Fatalln("fail to connect, err:", err)
 	}
 	defer conn.Close()
 	prepareDatabase(conn)
@@ -32,6 +32,6 @@ func main() {
 
 	err = conn.OpenTSDBInsertJsonPayload(payload)
 	if err != nil {
-		fmt.Println("insert error:", err)
+		log.Fatalln("insert error:", err)
 	}
 }

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

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"log"
 
 	"github.com/taosdata/driver-go/v3/af"
 )
@@ -33,6 +34,6 @@ func main() {
 
 	err = conn.InfluxDBInsertLines(lines, "ms")
 	if err != nil {
-		fmt.Println("insert error:", err)
+		log.Fatalln("insert error:", err)
 	}
 }

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

@@ -3,6 +3,7 @@ package main
 import (
 	"database/sql"
 	"fmt"
+	"log"
 
 	_ "github.com/taosdata/driver-go/v3/taosRestful"
 )
@@ -10,28 +11,26 @@ import (
 func createStable(taos *sql.DB) {
 	_, err := taos.Exec("CREATE DATABASE power")
 	if err != nil {
-		fmt.Println("failed to create database, err:", err)
+		log.Fatalln("failed to create database, err:", err)
 	}
 	_, err = taos.Exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)")
 	if err != nil {
-		fmt.Println("failed to create stable, err:", err)
+		log.Fatalln("failed to create stable, err:", err)
 	}
 }
 
 func insertData(taos *sql.DB) {
-	sql := `INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
-	power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
-	power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
-	power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`
+	sql := `INSERT INTO power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+	power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+	power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+	power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`
 	result, err := taos.Exec(sql)
 	if err != nil {
-		fmt.Println("failed to insert, err:", err)
-		return
+		log.Fatalln("failed to insert, err:", err)
 	}
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		fmt.Println("failed to get affected rows, err:", err)
-		return
+		log.Fatalln("failed to get affected rows, err:", err)
 	}
 	fmt.Println("RowsAffected", rowsAffected)
 }
@@ -40,8 +39,7 @@ func main() {
 	var taosDSN = "root:taosdata@http(localhost:6041)/"
 	taos, err := sql.Open("taosRestful", taosDSN)
 	if err != nil {
-		fmt.Println("failed to connect TDengine, err:", err)
-		return
+		log.Fatalln("failed to connect TDengine, err:", err)
 	}
 	defer taos.Close()
 	createStable(taos)

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

@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/taosdata/driver-go/v3/af"
-	"github.com/taosdata/driver-go/v3/af/param"
 	"github.com/taosdata/driver-go/v3/common"
+	"github.com/taosdata/driver-go/v3/common/param"
 )
 
 func checkErr(err error, prompt string) {

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

 package main
 
 import (
-	"fmt"
+	"log"
 
 	"github.com/taosdata/driver-go/v3/af"
 )
@@ -20,7 +20,7 @@ func prepareDatabase(conn *af.Connector) {
 func main() {
 	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
 	if err != nil {
-		fmt.Println("fail to connect, err:", err)
+		log.Fatalln("fail to connect, err:", err)
 	}
 	defer conn.Close()
 	prepareDatabase(conn)
@@ -37,6 +37,6 @@ func main() {
 
 	err = conn.OpenTSDBInsertTelnetLines(lines)
 	if err != nil {
-		fmt.Println("insert error:", err)
+		log.Fatalln("insert error:", err)
 	}
 }

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

@@ -2,7 +2,7 @@ package main
 
 import (
 	"database/sql"
-	"fmt"
+	"log"
 	"time"
 
 	_ "github.com/taosdata/driver-go/v3/taosRestful"
@@ -12,14 +12,12 @@ func main() {
 	var taosDSN = "root:taosdata@http(localhost:6041)/power"
 	taos, err := sql.Open("taosRestful", taosDSN)
 	if err != nil {
-		fmt.Println("failed to connect TDengine, err:", err)
-		return
+		log.Fatalln("failed to connect TDengine, err:", err)
 	}
 	defer taos.Close()
 	rows, err := taos.Query("SELECT ts, current FROM meters LIMIT 2")
 	if err != nil {
-		fmt.Println("failed to select from table, err:", err)
-		return
+		log.Fatalln("failed to select from table, err:", err)
 	}
 
 	defer rows.Close()
@@ -30,9 +28,9 @@ func main() {
 		}
 		err := rows.Scan(&r.ts, &r.current)
 		if err != nil {
-			fmt.Println("scan error:\n", err)
+			log.Fatalln("scan error:\n", err)
 			return
 		}
-		fmt.Println(r.ts, r.current)
+		log.Println(r.ts, r.current)
 	}
 }

docs/examples/node/nativeexample/async_query_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 const conn = taos.connect({ host: "localhost", database: "power" });
 const cursor = conn.cursor();
 
@@ -18,4 +18,3 @@ try {
     conn.close();
   }, 2000);
 }
-// bug here: jira 14506

docs/examples/node/nativeexample/connect.js

-const taos = require("td2.0-connector");
+const { options, connect } = require("@tdengine/rest");
 
-var conn = taos.connect({
-  host: "localhost",
-  port: 6030,
-  user: "root",
-  password: "taosdata",
-});
-conn.close();
+async function test() {
+  options.path = "/rest/sql";
+  options.host = "localhost";
+  let conn = connect(options);
+  let cursor = conn.cursor();
+  try {
+    let res = await cursor.query("SELECT server_version()");
+    res.toString();
+  } catch (err) {
+    console.log(err);
+  }
+}
+test();
 
-// run with: node connect.js
 // output:
-// Successfully connected to TDengine
+// server_version() |
+// ===================
+// 3.0.0.0          |

docs/examples/node/nativeexample/influxdb_line_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",

docs/examples/node/nativeexample/insert_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",
@@ -11,11 +11,11 @@ try {
   cursor.execute(
     "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)"
   );
-  var sql = `INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
-power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
-power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
-power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`;
-  cursor.execute(sql);
+  var sql = `INSERT INTO power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`;
+  cursor.execute(sql,{'quiet':false});
 } finally {
   cursor.close();
   conn.close();

docs/examples/node/nativeexample/multi_bind_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",
@@ -24,10 +24,10 @@ function insertData() {
   );
 
   // bind table name and tags
-  let tagBind = new taos.TaosBind(2);
-  tagBind.bindBinary("California.SanFrancisco");
-  tagBind.bindInt(2);
-  cursor.stmtSetTbnameTags("d1001", tagBind.getBind());
+  let tagBind = new taos.TaosMultiBindArr(2);
+  tagBind.multiBindBinary(["California.SanFrancisco"]);
+  tagBind.multiBindInt([2]);
+  cursor.stmtSetTbnameTags("d1001", tagBind.getMultiBindArr());
 
   // bind values
   let valueBind = new taos.TaosMultiBindArr(4);

docs/examples/node/nativeexample/opentsdb_json_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",

docs/examples/node/nativeexample/opentsdb_telnet_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",

docs/examples/node/nativeexample/param_bind_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({
   host: "localhost",
@@ -23,25 +23,22 @@ function insertData() {
   );
 
   // bind table name and tags
-  let tagBind = new taos.TaosBind(2);
-  tagBind.bindBinary("California.SanFrancisco");
-  tagBind.bindInt(2);
-  cursor.stmtSetTbnameTags("d1001", tagBind.getBind());
+  let tagBind = new taos.TaosMultiBindArr(2);
+  tagBind.multiBindBinary(["California.SanFrancisco"]);
+  tagBind.multiBindInt([2]);
+  cursor.stmtSetTbnameTags("d1001", tagBind.getMultiBindArr());
 
   // bind values
-  let rows = [
-    [1648432611249, 10.3, 219, 0.31],
-    [1648432611749, 12.6, 218, 0.33],
-  ];
-  for (let row of rows) {
-    let valueBind = new taos.TaosBind(4);
-    valueBind.bindTimestamp(row[0]);
-    valueBind.bindFloat(row[1]);
-    valueBind.bindInt(row[2]);
-    valueBind.bindFloat(row[3]);
-    cursor.stmtBindParam(valueBind.getBind());
-    cursor.stmtAddBatch();
-  }
+  let rows = [[1648432611249, 1648432611749], [10.3, 12.6], [219, 218], [0.31, 0.33]];
+
+  let valueBind = new taos.TaosMultiBindArr(4);
+  valueBind.multiBindTimestamp(rows[0]);
+  valueBind.multiBindFloat(rows[1]);
+  valueBind.multiBindInt(rows[2]);
+  valueBind.multiBindFloat(rows[3]);
+  cursor.stmtBindParamBatch(valueBind.getMultiBindArr());
+  cursor.stmtAddBatch();
+
 
   // execute
   cursor.stmtExecute();

docs/examples/node/nativeexample/query_example.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({ host: "localhost", database: "power" });
 const cursor = conn.cursor();
@@ -9,8 +9,6 @@ query.execute().then(function (result) {
 
 // output:
 // Successfully connected to TDengine
-// Query OK, 2 row(s) in set (0.00317767s)
-
 //            ts             |         current          |
 // =======================================================
 // 2018-10-03 14:38:05.000   | 10.3                     |

docs/examples/node/nativeexample/subscribe_demo.js

-const taos = require("td2.0-connector");
+const taos = require("@tdengine/client");
 
 const conn = taos.connect({ host: "localhost", database: "power" });
-// 未完成
+var cursor = conn.cursor();
\ No newline at end of file
+
+function runConsumer() {
+
+    // create topic 
+    cursor.execute("create topic topic_name_example as select * from meters");
+
+    let consumer = taos.consumer({
+        'group.id': 'tg2',
+        'td.connect.user': 'root',
+        'td.connect.pass': 'taosdata',
+        'msg.with.table.name': 'true',
+        'enable.auto.commit': 'true'
+    });
+    
+    // subscribe the topic just created.
+    consumer.subscribe("topic_name_example");
+
+    // get subscribe topic list
+    let topicList = consumer.subscription();
+    console.log(topicList);
+
+    for (let i = 0; i < 5; i++) {
+        let msg = consumer.consume(100);
+        console.log(msg.topicPartition);
+        console.log(msg.block);
+        console.log(msg.fields)
+        consumer.commit(msg);
+        console.log(`=======consumer ${i} done`)
+    }
+
+    consumer.unsubscribe();
+    consumer.close();
+
+    // drop topic
+    cursor.execute("drop topic topic_name_example");
+}
+
+
+try {
+    runConsumer();
+} finally {
+
+    setTimeout(() => {
+        cursor.close();
+        conn.close();
+    }, 2000);
+}
\ No newline at end of file

docs/examples/node/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "license": "MIT",
   "dependencies": {
-    "td2.0-connector": "^2.0.12",
-    "td2.0-rest-connector": "^1.0.0"
+    "@tdengine/client": "^3.0.0",
+    "@tdengine/rest": "^3.0.0"
   }
 }

docs/examples/node/restexample/connect.js

-const { options, connect } = require("td2.0-rest-connector");
+const { options, connect } = require("@tdengine/rest");
 
 async function test() {
   options.path = "/rest/sqlt";
@@ -17,4 +17,4 @@ test();
 // output:
 // server_version() |
 // ===================
-// 2.4.0.12         |
+// 3.0.0.0          |

docs/examples/python/native_insert_example.py

 import taos
 
-lines = ["d1001,2018-10-03 14:38:05.000,10.30000,219,0.31000,California.SanFrancisco,2",
-         "d1004,2018-10-03 14:38:05.000,10.80000,223,0.29000,California.LosAngeles,3",
-         "d1003,2018-10-03 14:38:05.500,11.80000,221,0.28000,California.LosAngeles,2",
-         "d1004,2018-10-03 14:38:06.500,11.50000,221,0.35000,California.LosAngeles,3",
-         "d1002,2018-10-03 14:38:16.650,10.30000,218,0.25000,California.SanFrancisco,3",
-         "d1001,2018-10-03 14:38:15.000,12.60000,218,0.33000,California.SanFrancisco,2",
-         "d1001,2018-10-03 14:38:16.800,12.30000,221,0.31000,California.SanFrancisco,2",
-         "d1003,2018-10-03 14:38:16.600,13.40000,223,0.29000,California.LosAngeles,2"]
+lines = ["d1001,2018-10-03 14:38:05.000,10.30000,219,0.31000,'California.SanFrancisco',2",
+         "d1004,2018-10-03 14:38:05.000,10.80000,223,0.29000,'California.LosAngeles',3",
+         "d1003,2018-10-03 14:38:05.500,11.80000,221,0.28000,'California.LosAngeles',2",
+         "d1004,2018-10-03 14:38:06.500,11.50000,221,0.35000,'California.LosAngeles',3",
+         "d1002,2018-10-03 14:38:16.650,10.30000,218,0.25000,'California.SanFrancisco',3",
+         "d1001,2018-10-03 14:38:15.000,12.60000,218,0.33000,'California.SanFrancisco',2",
+         "d1001,2018-10-03 14:38:16.800,12.30000,221,0.31000,'California.SanFrancisco',2",
+         "d1003,2018-10-03 14:38:16.600,13.40000,223,0.29000,'California.LosAngeles',2"]
 
 
 def get_connection() -> taos.TaosConnection:

docs/examples/rust/Cargo.toml

 [workspace]
-members = ["restexample", "nativeexample", "schemalessexample"]
+members = ["restexample", "nativeexample"]

docs/examples/rust/nativeexample/Cargo.toml

@@ -5,6 +5,9 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
-libtaos = { version = "0.4.3" }
-tokio = { version = "*", features = ["rt", "macros", "rt-multi-thread"] }
-bstr = { version = "*" }
+anyhow = "1"
+chrono = "0.4"
+serde = { version = "1", features = ["derive"] }
+tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
+
+taos = { version = "0.*" }

docs/examples/rust/nativeexample/examples/connect.rs

-use libtaos::*;
+use taos::*;
 
-fn taos_connect() -> Result<Taos, Error> {
-    TaosCfgBuilder::default()
-        .ip("localhost")
-        .user("root")
-        .pass("taosdata")
-        // .db("log") // remove comment if you want to connect to database log by default.
-        .port(6030u16)
-        .build()
-        .expect("TaosCfg builder error")
-        .connect()
-}
-
-fn main() {
+#[tokio::main]
+async fn main() -> Result<(), Error> {
     #[allow(unused_variables)]
-    let taos = taos_connect().unwrap();
-    println!("Connected")
+    let taos = TaosBuilder::from_dsn("taos://")?.build()?;
+    println!("Connected");
+    Ok(())
 }

docs/examples/rust/nativeexample/examples/stmt_example.rs

-use bstr::BString;
-use libtaos::*;
+use taos::*;
 
 #[tokio::main]
-async fn main() -> Result<(), Error> {
-    let taos = TaosCfg::default().connect().expect("fail to connect");
+async fn main() -> anyhow::Result<()> {
+    let taos = TaosBuilder::from_dsn("taos://")?.build()?;
     taos.create_database("power").await?;
     taos.use_database("power").await?;
-    taos.exec("CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)").await?;
-    let mut stmt = taos.stmt("INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)")?;
+    taos.exec("CREATE STABLE IF NOT EXISTS meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)").await?;
+
+    let mut stmt = Stmt::init(&taos)?;
+    stmt.prepare("INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)")?;
     // bind table name and tags
     stmt.set_tbname_tags(
         "d1001",
-        [
-            Field::Binary(BString::from("California.SanFrancisco")),
-            Field::Int(2),
-        ],
+        &[Value::VarChar("San Fransico".into()), Value::Int(2)],
     )?;
     // bind values.
     let values = vec![
-        Field::Timestamp(Timestamp::new(1648432611249, TimestampPrecision::Milli)),
-        Field::Float(10.3),
-        Field::Int(219),
-        Field::Float(0.31),
+        ColumnView::from_millis_timestamp(vec![1648432611249]),
+        ColumnView::from_floats(vec![10.3]),
+        ColumnView::from_ints(vec![219]),
+        ColumnView::from_floats(vec![0.31]),
     ];
     stmt.bind(&values)?;
     // bind one more row
     let values2 = vec![
-        Field::Timestamp(Timestamp::new(1648432611749, TimestampPrecision::Milli)),
-        Field::Float(12.6),
-        Field::Int(218),
-        Field::Float(0.33),
+        ColumnView::from_millis_timestamp(vec![1648432611749]),
+        ColumnView::from_floats(vec![12.6]),
+        ColumnView::from_ints(vec![218]),
+        ColumnView::from_floats(vec![0.33]),
     ];
     stmt.bind(&values2)?;
-    // execute
-    stmt.execute()?;
+    
+    stmt.add_batch()?;
+    
+    // execute.
+    let rows = stmt.execute()?;
+    assert_eq!(rows, 2);
     Ok(())
 }

docs/examples/rust/nativeexample/examples/subscribe_demo.rs

-fn main() {
-  
-}
+use std::time::Duration;
+
+use chrono::{DateTime, Local};
\ No newline at end of file
+use taos::*;
+
+// Query options 2, use deserialization with serde.
+#[derive(Debug, serde::Deserialize)]
+#[allow(dead_code)]
+struct Record {
+    // deserialize timestamp to chrono::DateTime<Local>
+    ts: DateTime<Local>,
+    // float to f32
+    current: Option<f32>,
+    // int to i32
+    voltage: Option<i32>,
+    phase: Option<f32>,
+}
+
+async fn prepare(taos: Taos) -> anyhow::Result<()> {
+    let inserted = taos.exec_many([
+        // create child table
+        "CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')",
+        // insert into child table
+        "INSERT INTO `d0` values(now - 10s, 10, 116, 0.32)",
+        // insert with NULL values
+        "INSERT INTO `d0` values(now - 8s, NULL, NULL, NULL)",
+        // insert and automatically create table with tags if not exists
+        "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119, 0.33)",
+        // insert many records in a single sql
+        "INSERT INTO `d1` values (now-8s, 10, 120, 0.33) (now - 6s, 10, 119, 0.34) (now - 4s, 11.2, 118, 0.322)",
+    ]).await?;
+    assert_eq!(inserted, 6);
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let dsn = "taos://localhost:6030";
+    let builder = TaosBuilder::from_dsn(dsn)?;
+
+    let taos = builder.build()?;
+    let db = "tmq";
+
+    // prepare database
+    taos.exec_many([
+        format!("DROP TOPIC IF EXISTS tmq_meters"),
+        format!("DROP DATABASE IF EXISTS `{db}`"),
+        format!("CREATE DATABASE `{db}`"),
+        format!("USE `{db}`"),
+        // create super table
+        format!("CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) TAGS (`groupid` INT, `location` BINARY(16))"),
+        // create topic for subscription
+        format!("CREATE TOPIC tmq_meters with META AS DATABASE {db}")
+    ])
+    .await?;
+
+    let task = tokio::spawn(prepare(taos));
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    // subscribe
+    let tmq = TmqBuilder::from_dsn("taos://localhost:6030/?group.id=test")?;
+
+    let mut consumer = tmq.build()?;
+    consumer.subscribe(["tmq_meters"]).await?;
+
+    {
+        let mut stream = consumer.stream();
+
+        while let Some((offset, message)) = stream.try_next().await? {
+            // get information from offset
+
+            // the topic
+            let topic = offset.topic();
+            // the vgroup id, like partition id in kafka.
+            let vgroup_id = offset.vgroup_id();
+            println!("* in vgroup id {vgroup_id} of topic {topic}\n");
+
+            if let Some(data) = message.into_data() {
+                while let Some(block) = data.fetch_raw_block().await? {
+                    // one block for one table, get table name if needed
+                    let name = block.table_name();
+                    let records: Vec<Record> = block.deserialize().try_collect()?;
+                    println!(
+                        "** table: {}, got {} records: {:#?}\n",
+                        name.unwrap(),
+                        records.len(),
+                        records
+                    );
+                }
+            }
+            consumer.commit(offset).await?;
+        }
+    }
+
+    consumer.unsubscribe().await;
+
+    task.await??;
+
+    Ok(())
+}

docs/examples/rust/restexample/Cargo.toml

@@ -4,5 +4,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-libtaos = { version = "0.4.3", features = ["rest"] }
-tokio = { version = "*", features = ["rt", "macros", "rt-multi-thread"] }
+anyhow = "1"
+chrono = "0.4"
+serde = { version = "1", features = ["derive"] }
+tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
+
+taos = { version = "0.*" }

docs/examples/rust/restexample/examples/connect.rs

-use libtaos::*;
-
-fn taos_connect() -> Result<Taos, Error> {
-    TaosCfgBuilder::default()
-        .ip("localhost")
-        .user("root")
-        .pass("taosdata")
-        // .db("log") // remove comment if you want to connect to database log by default.
-        .port(6030u16)
-        .build()
-        .expect("TaosCfg builder error")
-        .connect()
-}
+use taos::*;
 
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), Error> {
     #[allow(unused_variables)]
-    let taos = taos_connect().expect("connect error");
-    println!("Connected")
+    let taos = TaosBuilder::from_dsn("taos://")?.build()?;
+    println!("Connected");
+    Ok(())
 }

docs/examples/rust/restexample/examples/insert_example.rs

-use libtaos::*;
+use taos::*;
 
 #[tokio::main]
-async fn main() -> Result<(), Error> {
-    let taos = TaosCfg::default().connect().expect("fail to connect");
-    taos.create_database("power").await?;
-    taos.exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)").await?;
-    let sql = "INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
-    power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
-    power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
-    power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)";
-    let result = taos.query(sql).await?;
-    println!("{:?}", result);
+async fn main() -> anyhow::Result<()> {
+    let dsn = "ws://";
+    let taos = TaosBuilder::from_dsn(dsn)?.build()?;
+
+
+    taos.exec_many([
+        "DROP DATABASE IF EXISTS power",
+        "CREATE DATABASE power",
+        "USE power",
+        "CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)"
+    ]).await?;
+
+    let inserted = taos.exec("INSERT INTO 
+    power.d1001 USING power.meters TAGS('San Francisco', 2)
+     VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) 
+     ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+    power.d1002 USING power.meters TAGS('San Francisco', 3)
+     VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+    power.d1003 USING power.meters TAGS('Los Angeles', 2) 
+     VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+    power.d1004 USING power.meters TAGS('Los Angeles', 3) 
+     VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)").await?;
+
+    assert_eq!(inserted, 8);
     Ok(())
 }
-
-// output:
-// TaosQueryData { column_meta: [ColumnMeta { name: "affected_rows", type_: Int, bytes: 4 }], rows: [[Int(8)]] }

docs/examples/rust/restexample/examples/query_example.rs

-use libtaos::*;
+use taos::sync::*;
 
-fn taos_connect() -> Result<Taos, Error> {
-    TaosCfgBuilder::default()
-        .ip("localhost")
-        .user("root")
-        .pass("taosdata")
-        .db("power")
-        .port(6030u16)
-        .build()
-        .expect("TaosCfg builder error")
-        .connect()
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    let taos = taos_connect().expect("connect error");
-    let result = taos.query("SELECT ts, current FROM meters LIMIT 2").await?;
+fn main() -> anyhow::Result<()> {
+    let taos = TaosBuilder::from_dsn("ws:///power")?.build()?;
+    let mut result = taos.query("SELECT ts, current FROM meters LIMIT 2")?;
     // print column names
-    let meta: Vec<ColumnMeta> = result.column_meta;
-    for column in meta {
-        print!("{}\t", column.name)
-    }
-    println!();
+    let meta = result.fields();
+    println!("{}", meta.iter().map(|field| field.name()).join("\t"));
+
     // print rows
-    let rows: Vec<Vec<Field>> = result.rows;
+    let rows = result.rows();
     for row in rows {
-        for field in row {
-            print!("{}\t", field);
+        let row = row?;
+        for (_name, value) in row {
+            print!("{}\t", value);
         }
         println!();
     }
     Ok(())
 }
 
-// output:
+// output(suppose you are in +8 timezone):
 // ts      current
-// 2022-03-28 09:56:51.249 10.3
-// 2022-03-28 09:56:51.749 12.6
+// 2018-10-03T14:38:05+08:00       10.3
+// 2018-10-03T14:38:15+08:00       12.6

docs/examples/rust/schemalessexample/Cargo.toml

-[package]
-name = "schemalessexample"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-libtaos = { version = "0.4.3" }

docs/examples/rust/schemalessexample/examples/influxdb_line_example.rs

-use libtaos::schemaless::*;
-use libtaos::*;
-
-fn main() {
-    let taos = TaosCfg::default().connect().expect("fail to connect");
-    taos.raw_query("CREATE DATABASE test").unwrap();
-    taos.raw_query("USE test").unwrap();
-    let lines = ["meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
-    "meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
-    "meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
-    "meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250"];
-    let affected_rows = taos
-        .schemaless_insert(
-            &lines,
-            TSDB_SML_LINE_PROTOCOL,
-            TSDB_SML_TIMESTAMP_MILLISECONDS,
-        )
-        .unwrap();
-    println!("affected_rows={}", affected_rows);
-}
-
-// run with:  cargo run --example influxdb_line_example

docs/examples/rust/schemalessexample/examples/opentsdb_json_example.rs

-use libtaos::schemaless::*;
-use libtaos::*;
-
-fn main() {
-    let taos = TaosCfg::default().connect().expect("fail to connect");
-    taos.raw_query("CREATE DATABASE test").unwrap();
-    taos.raw_query("USE test").unwrap();
-    let lines = [
-        r#"[{"metric": "meters.current", "timestamp": 1648432611249, "value": 10.3, "tags": {"location": "California.SanFrancisco", "groupid": 2}},
-        {"metric": "meters.voltage", "timestamp": 1648432611249, "value": 219, "tags": {"location": "California.LosAngeles", "groupid": 1}},
-        {"metric": "meters.current", "timestamp": 1648432611250, "value": 12.6, "tags": {"location": "California.SanFrancisco", "groupid": 2}},
-        {"metric": "meters.voltage", "timestamp": 1648432611250, "value": 221, "tags": {"location": "California.LosAngeles", "groupid": 1}}]"#,
-    ];
-
-    let affected_rows = taos
-        .schemaless_insert(
-            &lines,
-            TSDB_SML_JSON_PROTOCOL,
-            TSDB_SML_TIMESTAMP_NOT_CONFIGURED,
-        )
-        .unwrap();
-    println!("affected_rows={}", affected_rows); // affected_rows=4
-}
-
-// run with:  cargo run --example opentsdb_json_example

docs/examples/rust/schemalessexample/examples/opentsdb_telnet_example.rs

-use libtaos::schemaless::*;
-use libtaos::*;
-
-fn main() {
-    let taos = TaosCfg::default().connect().expect("fail to connect");
-    taos.raw_query("CREATE DATABASE test").unwrap();
-    taos.raw_query("USE test").unwrap();
-    let lines = [
-        "meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
-        "meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
-        "meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
-        "meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
-        "meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
-        "meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
-        "meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
-        "meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
-    ];
-    let affected_rows = taos
-        .schemaless_insert(
-            &lines,
-            TSDB_SML_TELNET_PROTOCOL,
-            TSDB_SML_TIMESTAMP_NOT_CONFIGURED,
-        )
-        .unwrap();
-    println!("affected_rows={}", affected_rows); // affected_rows=8
-}
-
-// run with:  cargo run --example opentsdb_telnet_example

docs/examples/rust/schemalessexample/src/main.rs

-fn main() {
-    println!("Hello, world!");
-}

docs/zh/01-index.md

@@ -4,13 +4,13 @@ sidebar_label: 文档首页
 slug: /
 ---
 
-TDengine是一款开源、[高性能](https://www.taosdata.com/fast)、云原生的时序数据库(Time-Series Database, TSDB), 它专为物联网、工业互联网、金融等场景优化设计。同时它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本，是一极简的时序数据处理平台。本文档是 TDengine 用户手册，主要是介绍 TDengine 的基本概念、安装、使用、功能、开发接口、运营维护、TDengine 内核设计等等，它主要是面向架构师、开发者与系统管理员的。
+TDengine是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的时序数据库(Time-Series Database, TSDB), 它专为物联网、工业互联网、金融等场景优化设计。同时它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本，是一极简的时序数据处理平台。本文档是 TDengine 用户手册，主要是介绍 TDengine 的基本概念、安装、使用、功能、开发接口、运营维护、TDengine 内核设计等等，它主要是面向架构师、开发者与系统管理员的。
 
 TDengine 充分利用了时序数据的特点，提出了“一个数据采集点一张表”与“超级表”的概念，设计了创新的存储引擎，让数据的写入、查询和存储效率都得到极大的提升。为正确理解并使用TDengine, 无论如何，请您仔细阅读[基本概念](./concept)一章。
 
 如果你是开发者，请一定仔细阅读[开发指南](./develop)一章，该部分对数据库连接、建模、插入数据、查询、流式计算、缓存、数据订阅、用户自定义函数等功能都做了详细介绍，并配有各种编程语言的示例代码。大部分情况下，你只要把示例代码拷贝粘贴，针对自己的应用稍作改动，就能跑起来。
 
-我们已经生活在大数据的时代，纵向扩展已经无法满足日益增长的业务需求，任何系统都必须具有水平扩展的能力，集群成为大数据以及 database 系统的不可缺失功能。TDengine 团队不仅实现了集群功能，而且将这一重要核心功能开源。怎么部署、管理和维护 TDengine 集群，请参考[集群管理](./cluster)一章。
+我们已经生活在大数据的时代，纵向扩展已经无法满足日益增长的业务需求，任何系统都必须具有水平扩展的能力，集群成为大数据以及 database 系统的不可缺失功能。TDengine 团队不仅实现了集群功能，而且将这一重要核心功能开源。怎么部署、管理和维护 TDengine 集群，请参考[部署集群](./deployment)一章。
 
 TDengine 采用 SQL 作为其查询语言，大大降低学习成本、降低迁移成本，但同时针对时序数据场景，又做了一些扩展，以支持插值、降采样、时间加权平均等操作。[SQL 手册](./taos-sql)一章详细描述了 SQL 语法、详细列出了各种支持的命令和函数。
 

docs/zh/02-intro.md

@@ -3,7 +3,7 @@ title: 产品简介
 toc_max_heading_level: 2
 ---
 
-TDengine 是一款开源、高性能、云原生的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供[缓存](/develop/cache/)、[数据订阅](/develop/subscribe)、[流式计算](/develop/continuous-query)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。
+TDengine 是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/tdengine/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供[缓存](../develop/cache/)、[数据订阅](../develop/tmq)、[流式计算](../develop/stream)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。
 
 本章节介绍TDengine的主要功能、竞争优势、适用场景、与其他数据库的对比测试等等，让大家对TDengine有个整体的了解。
 
@@ -11,21 +11,22 @@ TDengine 是一款开源、高性能、云原生的时序数据库 (Time-Series
 
 TDengine的主要功能如下：
 
-1. 高速数据写入，除 [SQL 写入](/develop/insert-data/sql-writing)外，还支持 [Schemaless 写入](/reference/schemaless/)，支持 [InfluxDB LINE 协议](/develop/insert-data/influxdb-line)，[OpenTSDB Telnet](/develop/insert-data/opentsdb-telnet), [OpenTSDB JSON ](/develop/insert-data/opentsdb-json)等协议写入；
-2. 第三方数据采集工具 [Telegraf](/third-party/telegraf)，[Prometheus](/third-party/prometheus)，[StatsD](/third-party/statsd)，[collectd](/third-party/collectd)，[icinga2](/third-party/icinga2), [TCollector](/third-party/tcollector), [EMQ](/third-party/emq-broker), [HiveMQ](/third-party/hive-mq-broker) 等都可以进行配置后，不用任何代码，即可将数据写入；
-3. 支持[各种查询](/develop/query-data),包括聚合查询、嵌套查询、降采样查询、插值等
-4. 支持[用户自定义函数](/develop/udf)
-5. 支持[缓存](/develop/cache)，将每张表的最后一条记录缓存起来，这样无需 Redis
-6. 支持[流式计算](/develop/continuous-query)(Stream Processing)
-7. 支持[数据订阅](/develop/subscribe)，而且可以指定过滤条件
-8. 支持[集群](/cluster/)，可以通过多节点进行水平扩展，并通过多副本实现高可靠
-9. 提供[命令行程序](/reference/taos-shell)，便于管理集群，检查系统状态，做即席查询
-10. 提供多种数据的[导入](/operation/import)、[导出](/operation/export)
-11. 支持对[TDengine 集群本身的监控](/operation/monitor)
-12. 提供 [C/C++](/reference/connector/cpp), [Java](/reference/connector/java), [Python](/reference/connector/python), [Go](/reference/connector/go), [Rust](/reference/connector/rust), [Node.js](/reference/connector/node) 等多种编程语言的[连接器](/reference/connector/)
-13. 支持 [REST 接口](/reference/rest-api/)
-14. 支持与[ Grafana 无缝集成](/third-party/grafana)
+1. 高速数据写入，除 [SQL 写入](../develop/insert-data/sql-writing)外，还支持 [Schemaless 写入](../reference/schemaless/)，支持 [InfluxDB LINE 协议](../develop/insert-data/influxdb-line)，[OpenTSDB Telnet](../develop/insert-data/opentsdb-telnet), [OpenTSDB JSON ](../develop/insert-data/opentsdb-json)等协议写入；
+2. 第三方数据采集工具 [Telegraf](../third-party/telegraf)，[Prometheus](../third-party/prometheus)，[StatsD](../third-party/statsd)，[collectd](../third-party/collectd)，[icinga2](../third-party/icinga2), [TCollector](../third-party/tcollector), [EMQ](../third-party/emq-broker), [HiveMQ](../third-party/hive-mq-broker) 等都可以进行配置后，不用任何代码，即可将数据写入；
+3. 支持[各种查询](../develop/query-data),包括聚合查询、嵌套查询、降采样查询、插值等
+4. 支持[用户自定义函数](../develop/udf)
+5. 支持[缓存](../develop/cache)，将每张表的最后一条记录缓存起来，这样无需 Redis
+6. 支持[流式计算](../develop/stream)(Stream Processing)
+7. 支持[数据订阅](../develop/tmq)，而且可以指定过滤条件
+8. 支持[集群](../deployment/)，可以通过多节点进行水平扩展，并通过多副本实现高可靠
+9. 提供[命令行程序](../reference/taos-shell)，便于管理集群，检查系统状态，做即席查询
+10. 提供多种数据的[导入](../operation/import)、[导出](../operation/export)
+11. 支持对[TDengine 集群本身的监控](../operation/monitor)
+12. 提供 [C/C++](../reference/connector/cpp), [Java](../reference/connector/java), [Python](../reference/connector/python), [Go](../reference/connector/go), [Rust](../reference/connector/rust), [Node.js](../reference/connector/node) 等多种编程语言的[连接器](../reference/connector/)
+13. 支持 [REST 接口](../reference/rest-api/)
+14. 支持与[ Grafana 无缝集成](../third-party/grafana)
 15. 支持与 Google Data Studio 无缝集成
+16. 支持 [Kubernetes 部署](../deployment/k8s)
 
 更多细小的功能，请阅读整个文档。
 
@@ -33,17 +34,17 @@ TDengine的主要功能如下：
 
 由于 TDengine 充分利用了[时序数据特点](https://www.taosdata.com/blog/2019/07/09/105.html)，比如结构化、无需事务、很少删除或更新、写多读少等等，设计了全新的针对时序数据的存储引擎和计算引擎，因此与其他时序数据库相比，TDengine 有以下特点：
 
-- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。
+- **[高性能](https://www.taosdata.com/tdengine/fast)**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。
 
-- **云原生**：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。
+- **[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)**：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。
 
-- **极简时序数据平台**：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。
+- **[极简时序数据平台](https://www.taosdata.com/tdengine/simplified_solution_for_time-series_data_processing)**：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。
 
-- **分析能力**：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。
+- **[分析能力](https://www.taosdata.com/tdengine/easy_data_analytics)**：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。
 
-- **简单易用**：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。
+- **[简单易用](https://www.taosdata.com/tdengine/ease_of_use)**：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。
 
-- **核心开源**：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。 
+- **[核心开源](https://www.taosdata.com/tdengine/open_source_time-series_database)**：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。 
 
 采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。表现在几个方面：
 

docs/zh/05-get-started/01-docker.md

@@ -2,6 +2,9 @@
 sidebar_label: Docker
 title: 通过 Docker 快速体验 TDengine
 ---
+:::info
+如果您希望为 TDengine 贡献代码或对内部技术实现感兴趣，请参考[TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
+:::
 
 本节首先介绍如何通过 Docker 快速体验 TDengine，然后介绍如何在 Docker 环境下体验 TDengine 的写入和查询功能。
 
@@ -10,9 +13,11 @@ title: 通过 Docker 快速体验 TDengine
 如果已经安装了 docker， 只需执行下面的命令。
 
 ```shell
-docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengine
+docker run -d -p 6030:6030 -p 6041/6041 -p 6043-6049/6043-6049 -p 6043-6049:6043-6049/udp tdengine/tdengine
 ```
 
+注意：TDengine 3.0 服务端仅使用 6030 TCP 端口。6041 为 taosAdapter 所使用提供 REST 服务端口。6043-6049 为 taosAdapter 提供第三方应用接入所使用端口，可根据需要选择是否打开。
+
 确定该容器已经启动并且在正常运行
 
 ```shell
@@ -27,87 +32,31 @@ docker exec -it <container name> bash
 
 然后就可以执行相关的 Linux 命令操作和访问 TDengine
 
-:::info
-
-Docker 工具自身的下载请参考 [Docker 官网文档](https://docs.docker.com/get-docker/)。
-
-安装完毕后可以在命令行终端查看 Docker 版本。如果版本号正常输出，则说明 Docker 环境已经安装成功。
-
-```bash
-$ docker -v
-Docker version 20.10.3, build 48d30b5
-```
-
-:::
+注: Docker 工具自身的下载和使用请参考 [Docker 官网文档](https://docs.docker.com/get-docker/)。
 
 ## 运行 TDengine CLI
 
-有两种方式在 Docker 环境下使用 TDengine CLI (taos) 访问 TDengine. 
-- 进入容器后，执行 taos 
-- 在宿主机使用容器映射到主机的端口进行访问 `taos -h <hostname> -P <port>`
+进入容器，执行 taos 
 
 ```
 $ taos
-Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
-Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
-
-Server is Enterprise   trial Edition, ver:3.0.0.0 and will expire at 2022-09-24 15:29:46.
 
 taos> 
 
 ```
 
-
-## 启动 REST 服务
-
-taosAdapter 是 TDengine 中提供 REST 服务的组件。下面这条命令会在容器中同时启动 `taosd` 和 `taosadapter` 两个服务组件。
-
-```bash
-docker run -d --name tdengine-all -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengine
-```
-
-如果想只启动 `taosadapter`：
-
-```bash
-docker run -d --name tdengine-taosa -p 6041-6049:6041-6049 -p 6041-6049:6041-6049/udp -e TAOS_FIRST_EP=tdengine-all tdengine/tdengine:3.0.0.0 taosadapter
-```
-
-如果想只启动 `taosd`：
-
-```bash
-docker run -d --name tdengine-taosd -p 6030-6042:6030-6042 -p 6030-6042:6030-6042/udp -e TAOS_DISABLE_ADAPTER=true tdengine/tdengine:3.0.0.0
-```
-
-## 访问 REST 接口
-
-可以在宿主机使用 curl 通过 RESTful 端口访问 Docker 容器内的 TDengine server。
-
-```
-curl -L -u root:taosdata -d "show databases" 127.0.0.1:6041/rest/sql
-```
-
-输出示例如下：
-
-```
-{"code":0,"column_meta":[["name","VARCHAR",64],["create_time","TIMESTAMP",8],["vgroups","SMALLINT",2],["ntables","BIGINT",8],["replica","TINYINT",1],["strict","VARCHAR",4],["duration","VARCHAR",10],["keep","VARCHAR",32],["buffer","INT",4],["pagesize","INT",4],["pages","INT",4],["minrows","INT",4],["maxrows","INT",4],["wal","TINYINT",1],["fsync","INT",4],["comp","TINYINT",1],["cacheModel","VARCHAR",11],["precision","VARCHAR",2],["single_stable","BOOL",1],["status","VARCHAR",10],["retention","VARCHAR",60]],"data":[["information_schema",null,null,14,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"ready"],["performance_schema",null,null,3,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"ready"]],"rows":2}
-```
-
-这条命令，通过 REST API 访问 TDengine server，这时连接的是从容器映射到主机的 6041 端口。
-
-TDengine REST API 详情请参考[官方文档](/reference/rest-api/)。
-
 ## 写入数据
 
 可以使用 TDengine 的自带工具 taosBenchmark 快速体验 TDengine 的写入。
 
-假定启动容器时已经将容器的6030端口映射到了宿主机的6030端口，则可以直接在宿主机命令行启动 taosBenchmark，也可以进入容器后执行：
+进入容器，启动 taosBenchmark：
 
    ```bash
    $ taosBenchmark
    
    ```
 
-   该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
+   该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "San Francisco" 或者 "Los Angeles"等城市名称。
 
    这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能。
 
@@ -115,7 +64,7 @@ TDengine REST API 详情请参考[官方文档](/reference/rest-api/)。
 
 ## 体验查询
 
-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。可以直接在宿主机上也可以进入容器后运行。
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。。
 
 查询超级表下记录总条数：
 
@@ -129,10 +78,10 @@ taos> select count(*) from test.meters;
 taos> select avg(current), max(voltage), min(phase) from test.meters;
 ```
 
-查询 location="California.SanFrancisco" 的记录总条数：
+查询 location="San Francisco" 的记录总条数：
 
 ```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
+taos> select count(*) from test.meters where location="San Francisco";
 ```
 
 查询 groupId=10 的所有记录的平均值、最大值、最小值等：
@@ -145,4 +94,8 @@ taos> select avg(current), max(voltage), min(phase) from test.meters where group
 
 ```sql
 taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```
+```
\ No newline at end of file
+
+## 其它
+
+更多关于在 Docker 环境下使用 TDengine 的细节，请参考 [在 Docker 下使用 TDengine](../../reference/docker)

docs/zh/05-get-started/03-package.md

@@ -11,7 +11,7 @@ import TabItem from "@theme/TabItem";
 
 :::
 
-TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统，rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包。
+在 Linux 系统上，TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统，rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包，也支持通过 `apt-get` 工具从线上进行安装。TDengine 也提供 Windows x64 平台的安装包。
 
 ## 安装
 
@@ -21,20 +21,20 @@ TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自
 
 **安装包仓库**
 
-```
+```bash
 wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
 ```
 
 如果安装 Beta 版需要安装包仓库
 
-```
+```bash
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
 ```
 
 **使用 apt-get 命令安装**
 
-```
+```bash
 sudo apt-get update
 apt-cache policy tdengine
 sudo apt-get install tdengine
@@ -46,114 +46,39 @@ apt-get 方式只适用于 Debian 或 Ubuntu 系统
 </TabItem>
 <TabItem label="Deb 安装" value="debinst">
 
-1、从官网下载获得 deb 安装包，例如 TDengine-server-2.4.0.7-Linux-x64.deb；
-2、进入到 TDengine-server-2.4.0.7-Linux-x64.deb 安装包所在目录，执行如下的安装命令：
-
-```
-$ sudo dpkg -i TDengine-server-2.4.0.7-Linux-x64.deb
-(Reading database ... 137504 files and directories currently installed.)
-Preparing to unpack TDengine-server-2.4.0.7-Linux-x64.deb ...
-TDengine is removed successfully!
-Unpacking tdengine (2.4.0.7) over (2.4.0.7) ...
-Setting up tdengine (2.4.0.7) ...
-Start to install TDengine...
-
-System hostname is: ubuntu-1804
-
-Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join
-OR leave it blank to build one:
-
-Enter your email address for priority support or enter empty to skip:
-Created symlink /etc/systemd/system/multi-user.target.wants/taosd.service → /etc/systemd/system/taosd.service.
+1. 从官网下载获得 deb 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.deb；
+2. 进入到 TDengine-server-3.0.0.0-Linux-x64.deb 安装包所在目录，执行如下的安装命令：
 
-To configure TDengine : edit /etc/taos/taos.cfg
-To start TDengine     : sudo systemctl start taosd
-To access TDengine    : taos -h ubuntu-1804 to login into TDengine server
-
-
-TDengine is installed successfully!
+```bash
+sudo dpkg -i TDengine-server-3.0.0.0-Linux-x64.deb
 ```
 
 </TabItem>
 
 <TabItem label="RPM 安装" value="rpminst">
 
-1、从官网下载获得 rpm 安装包，例如 TDengine-server-2.4.0.7-Linux-x64.rpm；
-2、进入到 TDengine-server-2.4.0.7-Linux-x64.rpm 安装包所在目录，执行如下的安装命令：
-
-```
-$ sudo rpm -ivh TDengine-server-2.4.0.7-Linux-x64.rpm
-Preparing...                          ################################# [100%]
-Updating / installing...
-   1:tdengine-2.4.0.7-3               ################################# [100%]
-Start to install TDengine...
-
-System hostname is: centos7
-
-Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join
-OR leave it blank to build one:
-
-Enter your email address for priority support or enter empty to skip:
-
-Created symlink from /etc/systemd/system/multi-user.target.wants/taosd.service to /etc/systemd/system/taosd.service.
-
-To configure TDengine : edit /etc/taos/taos.cfg
-To start TDengine     : sudo systemctl start taosd
-To access TDengine    : taos -h centos7 to login into TDengine server
+1. 从官网下载获得 rpm 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.rpm；
+2. 进入到 TDengine-server-3.0.0.0-Linux-x64.rpm 安装包所在目录，执行如下的安装命令：
 
-
-TDengine is installed successfully!
+```bash
+sudo rpm -ivh TDengine-server-3.0.0.0-Linux-x64.rpm
 ```
 
 </TabItem>
 
 <TabItem label="tar.gz 安装" value="tarinst">
 
-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 安装脚本：
+1. 从官网下载获得 tar.gz 安装包，例如 TDengine-server-3.0.0.0-Linux-x64.tar.gz；
+2. 进入到 TDengine-server-3.0.0.0-Linux-x64.tar.gz 安装包所在目录，先解压文件后，进入子目录，执行其中的 install.sh 安装脚本：
 
+```bash
+tar -zxvf TDengine-server-3.0.0.0-Linux-x64.tar.gz
 ```
-$ tar xvzf TDengine-enterprise-server-2.4.0.7-Linux-x64.tar.gz
-TDengine-enterprise-server-2.4.0.7/
-TDengine-enterprise-server-2.4.0.7/driver/
-TDengine-enterprise-server-2.4.0.7/driver/vercomp.txt
-TDengine-enterprise-server-2.4.0.7/driver/libtaos.so.2.4.0.7
-TDengine-enterprise-server-2.4.0.7/install.sh
-TDengine-enterprise-server-2.4.0.7/examples/
-...
-
-$ ll
-total 43816
-drwxrwxr-x  3 ubuntu ubuntu     4096 Feb 22 09:31 ./
-drwxr-xr-x 20 ubuntu ubuntu     4096 Feb 22 09:30 ../
-drwxrwxr-x  4 ubuntu ubuntu     4096 Feb 22 09:30 TDengine-enterprise-server-2.4.0.7/
--rw-rw-r--  1 ubuntu ubuntu 44852544 Feb 22 09:31 TDengine-enterprise-server-2.4.0.7-Linux-x64.tar.gz
-
-$ cd TDengine-enterprise-server-2.4.0.7/
-
- $ ll
-total 40784
-drwxrwxr-x  4 ubuntu ubuntu     4096 Feb 22 09:30 ./
-drwxrwxr-x  3 ubuntu ubuntu     4096 Feb 22 09:31 ../
-drwxrwxr-x  2 ubuntu ubuntu     4096 Feb 22 09:30 driver/
-drwxrwxr-x 10 ubuntu ubuntu     4096 Feb 22 09:30 examples/
--rwxrwxr-x  1 ubuntu ubuntu    33294 Feb 22 09:30 install.sh*
--rw-rw-r--  1 ubuntu ubuntu 41704288 Feb 22 09:30 taos.tar.gz
-
-$ sudo ./install.sh
-
-Start to update TDengine...
-Created symlink /etc/systemd/system/multi-user.target.wants/taosd.service → /etc/systemd/system/taosd.service.
-Nginx for TDengine is updated successfully!
-
-To configure TDengine : edit /etc/taos/taos.cfg
-To configure Taos Adapter (if has) : edit /etc/taos/taosadapter.toml
-To start TDengine     : sudo systemctl start taosd
-To access TDengine    : use taos -h ubuntu-1804 in shell OR from http://127.0.0.1:6060
-
-TDengine is updated successfully!
-Install taoskeeper as a standalone service
-taoskeeper is installed, enable it by `systemctl enable taoskeeper`
+
+解压后进入相应路径，执行
+
+```bash
+sudo ./install.sh
 ```
 
 :::info
@@ -161,6 +86,13 @@ install.sh 安装脚本在执行过程中，会通过命令行交互界面询问
 
 :::
 
+</TabItem>
+
+<TabItem label="Windows 安装" value="windows">
+
+1. 从官网下载获得 exe 安装程序，例如 TDengine-server-3.0.0.0-Windows-x64.exe；
+2. 运行 TDengine-server-3.0.0.0-Windows-x64.exe 来安装 TDengine。
+
 </TabItem>
 </Tabs>
 
@@ -171,6 +103,9 @@ install.sh 安装脚本在执行过程中，会通过命令行交互界面询问
 
 ## 启动
 
+<Tabs>
+<TabItem label="Linux 系统" value="linux">
+
 安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
 
 ```bash
@@ -215,9 +150,18 @@ systemctl 命令汇总：
 
 :::
 
+</TabItem>
+
+<TabItem label="Windows 系统" value="windows">
+
+安装后，在 C:\TDengine 目录下，运行 taosd.exe 来启动 TDengine 服务进程。
+
+</TabItem>
+</Tabs>
+
 ## TDengine 命令行 (CLI)
 
-为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
+为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可，也可以在安装有 TDengine 的 Windows 终端的 C:\TDengine 目录下，运行 taos.exe 来启动 TDengine 命令行。
 
 ```bash
 taos
@@ -293,4 +237,4 @@ taos> select avg(current), max(voltage), min(phase) from test.meters where group
 
 ```sql
 taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```
+```
\ No newline at end of file

docs/zh/07-develop/03-insert-data/02-influxdb-line.mdx

@@ -54,9 +54,6 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
   <TabItem label="Go" value="go">
     <GoLine />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustLine />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeLine />
   </TabItem>

docs/zh/07-develop/03-insert-data/03-opentsdb-telnet.mdx

@@ -46,9 +46,6 @@ meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
   <TabItem label="Go" value="go">
     <GoTelnet />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustTelnet />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeTelnet />
   </TabItem>

docs/zh/07-develop/03-insert-data/04-opentsdb-json.mdx

@@ -63,9 +63,6 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
   <TabItem label="Go" value="go">
     <GoJson />
   </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustJson />
-  </TabItem>
   <TabItem label="Node.js" value="nodejs">
     <NodeJson />
   </TabItem>

docs/zh/07-develop/03-insert-data/_go_stmt.mdx

@@ -3,6 +3,6 @@
 ```
 
 :::tip
-driver-go 的模块 `github.com/taosdata/driver-go/v2/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现参数绑定写入。
+driver-go 的模块 `github.com/taosdata/driver-go/v3/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现参数绑定写入。
 
 :::

docs/zh/07-develop/03-insert-data/_rust_line.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/influxdb_line_example.rs}}
 ```

docs/zh/07-develop/03-insert-data/_rust_opts_json.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/opentsdb_json_example.rs}}
 ```

docs/zh/07-develop/03-insert-data/_rust_opts_telnet.mdx

 ```rust
-{{#include docs/examples/rust/schemalessexample/examples/opentsdb_telnet_example.rs}}
 ```

docs/zh/07-develop/04-query-data/index.mdx

@@ -25,6 +25,7 @@ TDengine 采用 SQL 作为查询语言。应用程序可以通过 REST API 或
 - 单列、多列数据查询
 - 标签和数值的多种过滤条件：>, <, =, <\>, like 等
 - 聚合结果的分组（Group by）、排序（Order by）、约束输出（Limit/Offset）
+- 时间窗口（Interval）、会话窗口（Session）和状态窗口（State_window）等窗口切分聚合查询
 - 数值列及聚合结果的四则运算
 - 时间戳对齐的连接查询（Join Query: 隐式连接）操作
 - 多种聚合/计算函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff 等
@@ -40,7 +41,7 @@ taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
 Query OK, 2 row(s) in set (0.001100s)
 ```
 
-为满足物联网场景的需求，TDengine 支持几个特殊的函数，比如 twa(时间加权平均)，spread (最大值与最小值的差)，last_row(最后一条记录)等，更多与物联网场景相关的函数将添加进来。TDengine 还支持连续查询。
+为满足物联网场景的需求，TDengine 支持几个特殊的函数，比如 twa(时间加权平均)，spread (最大值与最小值的差)，last_row(最后一条记录)等，更多与物联网场景相关的函数将添加进来。
 
 具体的查询语法请看 [TAOS SQL 的数据查询](/taos-sql/select) 章节。
 
@@ -73,7 +74,7 @@ taos> SELECT count(*), max(current) FROM meters where groupId = 2 and ts > now -
 Query OK, 1 row(s) in set (0.002136s)
 ```
 
-TDengine 仅容许对属于同一个超级表的表之间进行聚合查询，不同超级表之间的聚合查询不支持。在 [TAOS SQL 的数据查询](/taos-sql/select) 一章，查询类操作都会注明是否支持超级表。
+在 [TAOS SQL 的数据查询](/taos-sql/select) 一章，查询类操作都会注明是否支持超级表。
 
 ## 降采样查询、插值
 

docs/zh/07-develop/06-stream.md

----
-sidebar_label: 连续查询
-description: "连续查询是一个按照预设频率自动执行的查询功能，提供按照时间窗口的聚合查询能力，是一种简化的时间驱动流式计算。"
-title: "连续查询（Continuous Query）"
----
-
-连续查询是 TDengine 定期自动执行的查询，采用滑动窗口的方式进行计算，是一种简化的时间驱动的流式计算。针对库中的表或超级表，TDengine 可提供定期自动执行的连续查询，用户可让 TDengine 推送查询的结果，也可以将结果再写回到 TDengine 中。每次执行的查询是一个时间窗口，时间窗口随着时间流动向前滑动。在定义连续查询的时候需要指定时间窗口（time window, 参数 interval）大小和每次前向增量时间（forward sliding times, 参数 sliding）。
-
-TDengine 的连续查询采用时间驱动模式，可以直接使用 TAOS SQL 进行定义，不需要额外的操作。使用连续查询，可以方便快捷地按照时间窗口生成结果，从而对原始采集数据进行降采样（down sampling）。用户通过 TAOS SQL 定义连续查询以后，TDengine 自动在最后的一个完整的时间周期末端拉起查询，并将计算获得的结果推送给用户或者写回 TDengine。
-
-TDengine 提供的连续查询与普通流计算中的时间窗口计算具有以下区别：
-
-- 不同于流计算的实时反馈计算结果，连续查询只在时间窗口关闭以后才开始计算。例如时间周期是 1 天，那么当天的结果只会在 23:59:59 以后才会生成。
-- 如果有历史记录写入到已经计算完成的时间区间，连续查询并不会重新进行计算，也不会重新将结果推送给用户。对于写回 TDengine 的模式，也不会更新已经存在的计算结果。
-- 使用连续查询推送结果的模式，服务端并不缓存客户端计算状态，也不提供 Exactly-Once 的语义保证。如果用户的应用端崩溃，再次拉起的连续查询将只会从再次拉起的时间开始重新计算最近的一个完整的时间窗口。如果使用写回模式，TDengine 可确保数据写回的有效性和连续性。
-
-## 连续查询语法
-
-```sql
-[CREATE TABLE AS] SELECT select_expr [, select_expr ...]
-    FROM {tb_name_list}
-    [WHERE where_condition]
-    [INTERVAL(interval_val [, interval_offset]) [SLIDING sliding_val]]
-
-```
-
-INTERVAL: 连续查询作用的时间窗口
-
-SLIDING: 连续查询的时间窗口向前滑动的时间间隔
-
-## 使用连续查询
-
-下面以智能电表场景为例介绍连续查询的具体使用方法。假设我们通过下列 SQL 语句创建了超级表和子表：
-
-```sql
-create table meters (ts timestamp, current float, voltage int, phase float) tags (location binary(64), groupId int);
-create table D1001 using meters tags ("California.SanFrancisco", 2);
-create table D1002 using meters tags ("California.LosAngeles", 2);
-...
-```
-
-可以通过下面这条 SQL 语句以一分钟为时间窗口、30 秒为前向增量统计这些电表的平均电压。
-
-```sql
-select avg(voltage) from meters interval(1m) sliding(30s);
-```
-
-每次执行这条语句，都会重新计算所有数据。 如果需要每隔 30 秒执行一次来增量计算最近一分钟的数据，可以把上面的语句改进成下面的样子，每次使用不同的 `startTime` 并定期执行：
-
-```sql
-select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s);
-```
-
-这样做没有问题，但 TDengine 提供了更简单的方法，只要在最初的查询语句前面加上 `create table {tableName} as` 就可以了，例如：
-
-```sql
-create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s);
-```
-
-会自动创建一个名为 `avg_vol` 的新表，然后每隔 30 秒，TDengine 会增量执行 `as` 后面的 SQL 语句，并将查询结果写入这个表中，用户程序后续只要从 `avg_vol` 中查询数据即可。例如：
-
-```sql
-taos> select * from avg_vol;
-            ts           |        avg_voltage_    |
-===================================================
- 2020-07-29 13:37:30.000 |            222.0000000 |
- 2020-07-29 13:38:00.000 |            221.3500000 |
- 2020-07-29 13:38:30.000 |            220.1700000 |
- 2020-07-29 13:39:00.000 |            223.0800000 |
-```
-
-需要注意，查询时间窗口的最小值是 10 毫秒，没有时间窗口范围的上限。
-
-此外，TDengine 还支持用户指定连续查询的起止时间。如果不输入开始时间，连续查询将从第一条原始数据所在的时间窗口开始；如果没有输入结束时间，连续查询将永久运行；如果用户指定了结束时间，连续查询在系统时间达到指定的时间以后停止运行。比如使用下面的 SQL 创建的连续查询将运行一小时，之后会自动停止。
-
-```sql
-create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
-```
-
-需要说明的是，上面例子中的 `now` 是指创建连续查询的时间，而不是查询执行的时间，否则，查询就无法自动停止了。另外，为了尽量避免原始数据延迟写入导致的问题，TDengine 中连续查询的计算有一定的延迟。也就是说，一个时间窗口过去后，TDengine 并不会立即计算这个窗口的数据，所以要稍等一会（一般不会超过 1 分钟）才能查到计算结果。
-
-## 管理连续查询
-
-用户可在控制台中通过 `show streams` 命令来查看系统中全部运行的连续查询，并可以通过 `kill stream` 命令杀掉对应的连续查询。后续版本会提供更细粒度和便捷的连续查询管理命令。
+---
+sidebar_label: 流式计算
+description: "TDengine 流式计算将数据的写入、预处理、复杂分析、实时计算、报警触发等功能融为一体，是一个能够降低用户部署成本、存储成本和运维成本的计算引擎。"
+title: 流式计算
+---
+
+在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。用户通常需要在时序数据库之外再搭建 Kafka、Flink、Spark 等流计算处理引擎，增加了用户的开发成本和维护成本。
+使用 TDengine 3.0 的流式计算引擎能够最大限度的减少对这些额外中间件的依赖，真正将数据的写入、预处理、长期存储、复杂分析、实时计算、实时报警触发等功能融为一体，并且，所有这些任务只需要使用 SQL 完成，极大降低了用户的学习成本、使用成本。
+
+## 流式计算的创建
+
+```sql
+CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subquery
+stream_options: {
+ TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
+ WATERMARK   time
+ IGNORE EXPIRED
+}
+```
+
+详细的语法规则参考 [流式计算](../../taos-sql/stream)
+
+## 示例一
+
+企业电表的数据经常都是成百上千亿条的，那么想要将这些分散、凌乱的数据清洗或转换都需要比较长的时间，很难做到高效性和实时性，以下例子中，通过流计算可以将过去 12 小时电表电压大于 220V 的数据清洗掉，然后以小时为窗口整合并计算出每个窗口中电流的最大值，并将结果输出到指定的数据表中。
+
+### 创建 DB 和原始数据表
+
+首先准备数据，完成建库、建一张超级表和多张子表操作
+
+```sql
+drop database if exists stream_db;
+create database stream_db;
+
+create stable stream_db.meters (ts timestamp, current float, voltage int) TAGS (location varchar(64), groupId int);
+
+create table stream_db.d1001 using stream_db.meters tags("beijing", 1);
+create table stream_db.d1002 using stream_db.meters tags("guangzhou", 2);
+create table stream_db.d1003 using stream_db.meters tags("shanghai", 3);
+```
+
+### 创建流
+
+```sql
+create stream stream1 into stream_db.stream1_output_stb as select _wstart as start, _wend as end, max(current) as max_current from stream_db.meters where voltage <= 220 and ts > now - 12h interval (1h);
+```
+
+### 写入数据
+```sql
+insert into stream_db.d1001 values(now-14h, 10.3, 210);
+insert into stream_db.d1001 values(now-13h, 13.5, 216);
+insert into stream_db.d1001 values(now-12h, 12.5, 219);
+insert into stream_db.d1002 values(now-11h, 14.7, 221);
+insert into stream_db.d1002 values(now-10h, 10.5, 218);
+insert into stream_db.d1002 values(now-9h, 11.2, 220);
+insert into stream_db.d1003 values(now-8h, 11.5, 217);
+insert into stream_db.d1003 values(now-7h, 12.3, 227);
+insert into stream_db.d1003 values(now-6h, 12.3, 215);
+```
+
+### 查询以观查结果
+```sql
+taos> select * from stream_db.stream1_output_stb;
+          start          |           end           |     max_current      |       group_id        |
+===================================================================================================
+ 2022-08-09 14:00:00.000 | 2022-08-09 15:00:00.000 |             10.50000 |                     0 |
+ 2022-08-09 15:00:00.000 | 2022-08-09 16:00:00.000 |             11.20000 |                     0 |
+ 2022-08-09 16:00:00.000 | 2022-08-09 17:00:00.000 |             11.50000 |                     0 |
+ 2022-08-09 18:00:00.000 | 2022-08-09 19:00:00.000 |             12.30000 |                     0 |
+Query OK, 4 rows in database (0.012033s)
+```
+
+## 示例二
+某运营商平台要采集机房所有服务器的系统资源指标，包含 cpu、内存、网络延迟等，采集后需要对数据进行四舍五入运算，将地域和服务器名以下划线拼接，然后将结果按时间排序并以服务器名分组输出到新的数据表中。
+
+### 创建 DB 和原始数据表
+首先准备数据，完成建库、建一张超级表和多张子表操作
+
+```sql
+drop database if exists stream_db;
+create database stream_db;
+
+create stable stream_db.idc (ts timestamp, cpu float, mem float, latency float) TAGS (location varchar(64), groupId int);
+
+create table stream_db.server01 using stream_db.idc tags("beijing", 1);
+create table stream_db.server02 using stream_db.idc tags("shanghai", 2);
+create table stream_db.server03 using stream_db.idc tags("beijing", 2);
+create table stream_db.server04 using stream_db.idc tags("tianjin", 3);
+create table stream_db.server05 using stream_db.idc tags("shanghai", 1);
+```
+
+### 创建流
+
+```sql
+create stream stream2 into stream_db.stream2_output_stb as select ts, concat_ws("_", location, tbname) as server_location, round(cpu) as cpu, round(mem) as mem, round(latency) as latency from stream_db.idc partition by tbname order by ts;
+```
+
+### 写入数据
+```sql
+insert into stream_db.server01 values(now-14h, 50.9, 654.8, 23.11);
+insert into stream_db.server01 values(now-13h, 13.5, 221.2, 11.22);
+insert into stream_db.server02 values(now-12h, 154.7, 218.3, 22.33);
+insert into stream_db.server02 values(now-11h, 120.5, 111.5, 5.55);
+insert into stream_db.server03 values(now-10h, 101.5, 125.6, 5.99);
+insert into stream_db.server03 values(now-9h, 12.3, 165.6, 6.02);
+insert into stream_db.server04 values(now-8h, 160.9, 120.7, 43.51);
+insert into stream_db.server04 values(now-7h, 240.9, 520.7, 54.55);
+insert into stream_db.server05 values(now-6h, 190.9, 320.7, 55.43);
+insert into stream_db.server05 values(now-5h, 110.9, 600.7, 35.54);
+```
+### 查询以观查结果
+```sql
+taos> select ts, server_location, cpu, mem, latency from stream_db.stream2_output_stb;
+           ts            |        server_location         |         cpu          |         mem          |       latency        |
+================================================================================================================================
+ 2022-08-09 21:24:56.785 | beijing_server01               |             51.00000 |            655.00000 |             23.00000 |
+ 2022-08-09 22:24:56.795 | beijing_server01               |             14.00000 |            221.00000 |             11.00000 |
+ 2022-08-09 23:24:56.806 | shanghai_server02              |            155.00000 |            218.00000 |             22.00000 |
+ 2022-08-10 00:24:56.815 | shanghai_server02              |            121.00000 |            112.00000 |              6.00000 |
+ 2022-08-10 01:24:56.826 | beijing_server03               |            102.00000 |            126.00000 |              6.00000 |
+ 2022-08-10 02:24:56.838 | beijing_server03               |             12.00000 |            166.00000 |              6.00000 |
+ 2022-08-10 03:24:56.846 | tianjin_server04               |            161.00000 |            121.00000 |             44.00000 |
+ 2022-08-10 04:24:56.853 | tianjin_server04               |            241.00000 |            521.00000 |             55.00000 |
+ 2022-08-10 05:24:56.866 | shanghai_server05              |            191.00000 |            321.00000 |             55.00000 |
+ 2022-08-10 06:24:57.301 | shanghai_server05              |            111.00000 |            601.00000 |             36.00000 |
+Query OK, 10 rows in database (0.022950s)
+```
+

docs/zh/07-develop/07-tmq.md

 ---
-sidebar_label: 消息队列
-description: "数据订阅与推送服务。连续写入到 TDengine 中的时序数据能够被自动推送到订阅客户端。"
-title: 消息队列
+sidebar_label: 数据订阅
+description: "数据订阅与推送服务。写入到 TDengine 中的时序数据能够被自动推送到订阅客户端。"
+title: 数据订阅
 ---
 
-基于数据天然的时间序列特性，TDengine 的数据写入（insert）与消息系统的数据发布（pub）逻辑上一致，均可视为系统中插入一条带时间戳的新记录。同时，TDengine 在内部严格按照数据时间序列单调递增的方式保存数据。本质上来说，TDengine 中每一张表均可视为一个标准的消息队列。
+为了帮助应用实时获取写入 TDengine 的数据，或者以事件到达顺序处理数据，TDengine提供了类似消息队列产品的数据订阅、消费接口。这样在很多场景下，采用 TDengine 的时序数据处理系统不再需要集成消息队列产品，比如 kafka, 从而简化系统设计的复杂度，降低运营维护成本。
 
-TDengine 内嵌支持消息订阅与推送服务（下文都简称TMQ）。使用系统提供的 API，用户可使用普通查询语句订阅数据库中的一张或多张表，或整个库。客户端启动订阅后，定时或按需轮询服务器是否有新的记录到达，有新的记录到达就会将结果反馈到客户。
+与 kafka 一样，你需要定义 topic, 但 TDengine 的 topic 是基于一个已经存在的超级表、子表或普通表的查询条件，即一个 SELECT 语句。你可以使用 SQL 对标签、表名、列、表达式等条件进行过滤，以及对数据进行标量函数与 UDF 计算（不包括数据聚合）。与其他消息队列软件相比，这是 TDengine 数据订阅功能的最大的优势，它提供了更大的灵活性，数据的颗粒度可以由应用随时调整，而且数据的过滤与预处理交给 TDengine，而不是应用完成，有效的减少传输的数据量与应用的复杂度。
 
-TMQ提供了提交机制来保证消息队列的可靠性和正确性。在调用方法上，支持自动提交和手动提交。
+消费者订阅 topic 后，可以实时获得最新的数据。多个消费者可以组成一个消费者组 (consumer group), 一个消费者组里的多个消费者共享消费进度，便于多线程、分布式地消费数据，提高消费速度。但不同消费者组中的消费者即使消费同一个topic, 并不共享消费进度。一个消费者可以订阅多个 topic。如果订阅的是超级表，数据可能会分布在多个不同的 vnode 上，也就是多个 shard 上，这样一个消费组里有多个消费者可以提高消费效率。TDengine 的消息队列提供了消息的ACK机制，在宕机、重启等复杂环境下确保 at least once 消费。
+
+为了实现上述功能，TDengine 会为 WAL (Write-Ahead-Log) 文件自动创建索引以支持快速随机访问，并提供了灵活可配置的文件切换与保留机制：用户可以按需指定 WAL 文件保留的时间以及大小（详见 create database 语句）。通过以上方式将 WAL 改造成了一个保留事件到达顺序的、可持久化的存储引擎（但由于 TSDB 具有远比 WAL 更高的压缩率，我们不推荐保留太长时间，一般来说，不超过几天）。 对于以 topic 形式创建的查询，TDengine 将对接 WAL 而不是 TSDB 作为其存储引擎。在消费时，TDengine 根据当前消费进度从 WAL 直接读取数据，并使用统一的查询引擎实现过滤、变换等操作，将数据推送给消费者。
+
+本文档不对消息队列本身的基础知识做介绍，如果需要了解，请自行搜索。
+
+## 主要数据结构和API
 
 TMQ 的 API 中，与订阅相关的主要数据结构和API如下：
 
@@ -47,7 +53,9 @@ DLL_EXPORT void           tmq_conf_set_auto_commit_cb(tmq_conf_t *conf, tmq_comm
 
 这些 API 的文档请见 [C/C++ Connector](/reference/connector/cpp)，下面介绍一下它们的具体用法（超级表和子表结构请参考“数据建模”一节），完整的示例代码可以在 [tmq.c](https://github.com/taosdata/TDengine/blob/3.0/examples/c/tmq.c) 看到。
 
-一、首先完成建库、建一张超级表和多张子表，并每个子表插入若干条数据记录：
+## 写入数据
+
+首先完成建库、建一张超级表和多张子表操作，然后就可以写入数据了，比如：
 
 ```sql
 drop database if exists tmqdb;
@@ -63,14 +71,15 @@ insert into tmqdb.ctb2 values(now, 2, 2, 'a1')(now+1s, 22, 22, 'a22');
 insert into tmqdb.ctb3 values(now, 3, 3, 'a1')(now+1s, 33, 33, 'a33');
 ```
 
-二、创建topic：
+## 创建topic：
 
 ```sql
 create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
 ```
 
-注：TMQ支持多种订阅类型：
-1、列订阅
+TMQ支持多种订阅类型：
+
+### 列订阅
 
 语法：CREATE TOPIC topic_name as subquery
 通过select语句订阅（包括select *，或select ts, c1等指定列描述订阅，可以带条件过滤、标量函数计算，但不支持聚合函数、不支持时间窗口聚合）
@@ -79,25 +88,18 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
 - 被订阅或用于计算的column和tag不可被删除、修改
 - 若发生schema变更，新增的column不出现在结果中
 
-2、超级表订阅
+### 超级表订阅
 语法：CREATE TOPIC topic_name AS STABLE stbName
 
-- 订阅某超级表的全部数据，schema变更不受限，schema变更后写入的数据将以最新schema返回
-- 在tmq的返回消息中schema是块级别的，每块的schema可能不一样
-- 列变更后写入的数据若未落盘，将以写入时的schema返回
-- 列变更后写入的数据若已落盘，将以落盘时的schema返回
-
-3、db订阅
-语法：CREATE TOPIC topic_name AS DATABASE db_name
-
-- 订阅某一db的全部数据，schema变更不受限
-- 在tmq的返回消息中schema是块级别的，每块的schema可能不一样
-- 列变更后写入的数据若未落盘，将以写入时的schema返回
-- 列变更后写入的数据若已落盘，将以落盘时的schema返回
+与select * from stbName订阅的区别是：
+- 不会限制用户的schema变更
+- 返回的是非结构化的数据：返回数据的schema会随之超级表的schema变化而变化
+- 用户对于要处理的每一个数据块都可能有不同的schema，因此，必须重新获取schema
+- 返回数据不带有tag
 
-三、创建consumer
+## 创建 consumer 以及consumer group
 
-目前支持的config：
+对于consumer, 目前支持的config包括：
 
 | 参数名称                     | 参数值                         | 备注                                                   |
 | ---------------------------- | ------------------------------ | ------------------------------------------------------ |
@@ -121,7 +123,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   tmq_conf_set(conf, "group.id", "cgrpName");
   tmq_conf_set(conf, "td.connect.user", "root");
   tmq_conf_set(conf, "td.connect.pass", "taosdata");
-  tmq_conf_set(conf, "auto.offset.reset", "earliest");  
+  tmq_conf_set(conf, "auto.offset.reset", "earliest");
   tmq_conf_set(conf, "experimental.snapshot.enable", "true");
   tmq_conf_set(conf, "msg.with.table.name", "true");
   tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
@@ -131,7 +133,12 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   return tmq;
 ```
 
-四、创建订阅主题列表
+上述配置中包括consumer group ID，如果多个 consumer 指定的 consumer group ID一样，则自动形成一个consumer group，共享消费进度。
+
+
+## 创建 topic 列表
+
+单个consumer支持同时订阅多个topic。
 
 ```sql
   tmq_list_t* topicList = tmq_list_new();
@@ -139,9 +146,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   return topicList;
 ```
 
-单个consumer支持同时订阅多个topic。
-
-五、启动订阅并开始消费
+## 启动订阅并开始消费
 
 ```sql
   /* 启动订阅 */
@@ -151,9 +156,9 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   /* 循环poll消息 */
   int32_t totalRows = 0;
   int32_t msgCnt = 0;
-  int32_t consumeDelay = 5000;
+  int32_t timeOut = 5000;
   while (running) {
-    TAOS_RES* tmqmsg = tmq_consumer_poll(tmq, consumeDelay);
+    TAOS_RES* tmqmsg = tmq_consumer_poll(tmq, timeOut);
     if (tmqmsg) {
       msgCnt++;
       totalRows += msg_process(tmqmsg);
@@ -190,7 +195,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
     int32_t*    length      = taos_fetch_lengths(msg);
     int32_t     precision   = taos_result_precision(msg);
     const char* tbName      = tmq_get_table_name(msg);
-	rows++; 
+    rows++; 
     taos_print_row(buf, row, fields, numOfFields);
     printf("row content from %s: %s\n", (tbName != NULL ? tbName : "null table"), buf);
   }
@@ -199,7 +204,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
 }
 ```
 
-五、结束消费
+## 结束消费
 
 ```sql
   /* 取消订阅 */
@@ -209,7 +214,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   tmq_consumer_close(tmq);
 ```
 
-六、删除topic
+## 删除topic
 
 如果不再需要，可以删除创建topic，但注意：只有没有被订阅的topic才能别删除。
 
@@ -218,7 +223,7 @@ create topic topicName as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1;
   drop topic topicName;
 ```
 
-七、状态查看
+## 状态查看
 
 1、topics：查询已经创建的topic
 

docs/zh/07-develop/09-udf.md

@@ -4,58 +4,146 @@ title: UDF（用户定义函数）
 description: "支持用户编码的聚合函数和标量函数，在查询中嵌入并使用用户定义函数，拓展查询的能力和功能。"
 ---
 
-在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。 UDF 通常以数据表中的一列数据做为输入，同时支持以嵌套子查询的结果作为输入。
+在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF(User Defined Function) 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。 UDF 通常以数据表中的一列数据做为输入，同时支持以嵌套子查询的结果作为输入。
 
-从 2.2.0.0 版本开始，TDengine 支持通过 C/C++ 语言进行 UDF 定义。接下来结合示例讲解 UDF 的使用方法。
+TDengine 支持通过 C/C++ 语言进行 UDF 定义。接下来结合示例讲解 UDF 的使用方法。
 
-用户可以通过 UDF 实现两类函数： 标量函数 和 聚合函数。
+用户可以通过 UDF 实现两类函数：标量函数和聚合函数。标量函数对每行数据输出一个值，如求绝对值 abs，正弦函数 sin，字符串拼接函数 concat 等。聚合函数对多行数据进行输出一个值，如求平均数 avg，最大值 max 等。
 
-## 用 C/C++ 语言来定义 UDF
+实现 UDF 时，需要实现规定的接口函数
+- 标量函数需要实现标量接口函数 scalarfn 。
+- 聚合函数需要实现聚合接口函数 aggfn_start ， aggfn ， aggfn_finish。
+- 如果需要初始化，实现 udf_init；如果需要清理工作，实现udf_destroy。
 
-### 标量函数
+接口函数的名称是 UDF 名称，或者是 UDF 名称和特定后缀（_start, _finish, _init, _destroy)的连接。列表中的scalarfn，aggfn, udf需要替换成udf函数名。
 
-用户可以按照下列函数模板定义自己的标量计算函数
+## 实现标量函数
+标量函数实现模板如下
+```c
+#include "taos.h"
+#include "taoserror.h"
+#include "taosudf.h"
+
+// initialization function. if no initialization, we can skip definition of it. The initialization function shall be concatenation of the udf name and _init suffix
+// @return error number defined in taoserror.h
+int32_t scalarfn_init() {
+    // initialization.
+    return TSDB_CODE_SUCCESS;
+}
+
+// scalar function main computation function
+// @param inputDataBlock, input data block composed of multiple columns with each column defined by SUdfColumn
+// @param resultColumn, output column
+// @return error number defined in taoserror.h
+int32_t scalarfn(SUdfDataBlock* inputDataBlock, SUdfColumn* resultColumn) {
+    // read data from inputDataBlock and process, then output to resultColumn.
+    return TSDB_CODE_SUCCESS;
+}
+
+// cleanup function. if no cleanup related processing, we can skip definition of it. The destroy function shall be concatenation of the udf name and _destroy suffix.
+// @return error number defined in taoserror.h
+int32_t scalarfn_destroy() {
+    // clean up
+    return TSDB_CODE_SUCCESS;
+}
+```
+scalarfn 为函数名的占位符，需要替换成函数名，如bit_and。
+
+## 实现聚合函数
+
+聚合函数的实现模板如下
+```c
+#include "taos.h"
+#include "taoserror.h"
+#include "taosudf.h"
+
+// Initialization function. if no initialization, we can skip definition of it. The initialization function shall be concatenation of the udf name and _init suffix
+// @return error number defined in taoserror.h
+int32_t aggfn_init() {
+    // initialization.
+    return TSDB_CODE_SUCCESS;
+}
+
+// aggregate start function. The intermediate value or the state(@interBuf) is initialized in this function. The function name shall be concatenation of udf name and _start suffix
+// @param interbuf intermediate value to intialize
+// @return error number defined in taoserror.h
+int32_t aggfn_start(SUdfInterBuf* interBuf) {
+    // initialize intermediate value in interBuf
+    return TSDB_CODE_SUCESS;
+}
+
+// aggregate reduce function. This function aggregate old state(@interbuf) and one data bock(inputBlock) and output a new state(@newInterBuf).
+// @param inputBlock input data block
+// @param interBuf old state
+// @param newInterBuf new state
+// @return error number defined in taoserror.h
+int32_t aggfn(SUdfDataBlock* inputBlock, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf) {
+    // read from inputBlock and interBuf and output to newInterBuf
+    return TSDB_CODE_SUCCESS;
+}
+
+// aggregate function finish function. This function transforms the intermediate value(@interBuf) into the final output(@result). The function name must be concatenation of aggfn and _finish suffix.
+// @interBuf : intermediate value
+// @result: final result
+// @return error number defined in taoserror.h
+int32_t int32_t aggfn_finish(SUdfInterBuf* interBuf, SUdfInterBuf *result) {
+    // read data from inputDataBlock and process, then output to result
+    return TSDB_CODE_SUCCESS;
+}
+
+// cleanup function. if no cleanup related processing, we can skip definition of it. The destroy function shall be concatenation of the udf name and _destroy suffix.
+// @return error number defined in taoserror.h
+int32_t aggfn_destroy() {
+    // clean up
+    return TSDB_CODE_SUCCESS;
+}
+```
+aggfn为函数名的占位符，需要修改为自己的函数名，如l2norm。
+
+## 接口函数定义
+
+接口函数的名称是 udf 名称，或者是 udf 名称和特定后缀（_start, _finish, _init, _destroy)的连接。以下描述中函数名称中的 scalarfn，aggfn, udf 需要替换成udf函数名。
+
+接口函数返回值表示是否成功。如果返回值是 TSDB_CODE_SUCCESS，表示操作成功，否则返回的是错误代码。错误代码定义在 taoserror.h，和 taos.h 中的API共享错误码的定义。例如， TSDB_CODE_UDF_INVALID_INPUT 表示输入无效输入。TSDB_CODE_OUT_OF_MEMORY 表示内存不足。
+
+接口函数参数类型见数据结构定义。
+
+### 标量接口函数
 
- `int32_t udf(SUdfDataBlock* inputDataBlock, SUdfColumn *resultColumn)` 
+ `int32_t scalarfn(SUdfDataBlock* inputDataBlock, SUdfColumn *resultColumn)` 
  
- 其中 udf 是函数名的占位符，以上述模板实现的函数对行数据块进行标量计算。
+ 其中 scalarFn 是函数名的占位符。这个函数对数据块进行标量计算，通过设置resultColumn结构体中的变量设置值
 
-- scalarFunction 中各参数的具体含义是：
+参数的具体含义是：
   - inputDataBlock: 输入的数据块
-  - resultColumn: 输出列 
+  - resultColumn: 输出列。输出列 
 
-### 聚合函数
+### 聚合接口函数
 
-用户可以按照如下函数模板定义自己的聚合函数。
+`int32_t aggfn_start(SUdfInterBuf *interBuf)`
 
-`int32_t udf_start(SUdfInterBuf *interBuf)`
+`int32_t aggfn(SUdfDataBlock* inputBlock, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf)`
 
-`int32_t udf(SUdfDataBlock* inputBlock, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf)`
+`int32_t aggfn_finish(SUdfInterBuf* interBuf, SUdfInterBuf *result)`
 
-`int32_t udf_finish(SUdfInterBuf* interBuf, SUdfInterBuf *result)`
-其中 udf 是函数名的占位符。其中各参数的具体含义是：
+其中 aggfn 是函数名的占位符。首先调用aggfn_start生成结果buffer，然后相关的数据会被分为多个行数据块，对每个数据块调用 aggfn 用数据块更新中间结果，最后再调用 aggfn_finish 从中间结果产生最终结果，最终结果只能含 0 或 1 条结果数据。
 
+参数的具体含义是：
   - interBuf：中间结果 buffer。
   - inputBlock：输入的数据块。
   - newInterBuf：新的中间结果buffer。
   - result：最终结果。
 
 
-其计算过程为：首先调用udf_start生成结果buffer，然后相关的数据会被分为多个行数据块，对每个行数据块调用 udf 用数据块更新中间结果，最后再调用 udf_finish 从中间结果产生最终结果，最终结果只能含 0 或 1 条结果数据。
-
 ### UDF 初始化和销毁
 `int32_t udf_init()`
 
 `int32_t udf_destroy()`
 
-其中 udf 是函数名的占位符。udf_init 完成初始化工作。 udf_destroy 完成清理工作。
-
-:::note
-如果对应的函数不需要具体的功能，也需要实现一个空函数。
+其中 udf 是函数名的占位符。udf_init 完成初始化工作。 udf_destroy 完成清理工作。如果没有初始化工作，无需定义udf_init函数。如果没有清理工作，无需定义udf_destroy函数。
 
-:::
 
-### UDF 数据结构
+## UDF 数据结构
 ```c
 typedef struct SUdfColumnMeta {
   int16_t type;
@@ -103,6 +191,13 @@ typedef struct SUdfInterBuf {
   int8_t numOfResult; //zero or one
 } SUdfInterBuf;
 ```
+数据结构说明如下：
+
+- SUdfDataBlock 数据块包含行数 numOfRows 和列数 numCols。udfCols[i] (0 <= i <= numCols-1)表示每一列数据，类型为SUdfColumn*。
+- SUdfColumn 包含列的数据类型定义 colMeta 和列的数据 colData。
+- SUdfColumnMeta 成员定义同 taos.h 数据类型定义。
+- SUdfColumnData 数据可以变长，varLenCol 定义变长数据，fixLenCol 定义定长数据。 
+- SUdfInterBuf 定义中间结构 buffer，以及 buffer 中结果个数 numOfResult
 
 为了更好的操作以上数据结构，提供了一些便利函数，定义在 taosudf.h。
 
@@ -118,75 +213,15 @@ gcc -g -O0 -fPIC -shared add_one.c -o add_one.so
 
 这样就准备好了动态链接库 add_one.so 文件，可以供后文创建 UDF 时使用了。为了保证可靠的系统运行，编译器 GCC 推荐使用 7.5 及以上版本。
 
-## 在系统中管理和使用 UDF
-
-### 创建 UDF
-
-用户可以通过 SQL 指令在系统中加载客户端所在主机上的 UDF 函数库（不能通过 RESTful 接口或 HTTP 管理界面来进行这一过程）。一旦创建成功，则当前 TDengine 集群的所有用户都可以在 SQL 指令中使用这些函数。UDF 存储在系统的 MNode 节点上，因此即使重启 TDengine 系统，已经创建的 UDF 也仍然可用。
-
-在创建 UDF 时，需要区分标量函数和聚合函数。如果创建时声明了错误的函数类别，则可能导致通过 SQL 指令调用函数时出错。此外，用户需要保证输入数据类型与 UDF 程序匹配，UDF 输出数据类型与 OUTPUTTYPE 匹配。
-
-- 创建标量函数
-```sql
-CREATE FUNCTION function_name AS library_path OUTPUTTYPE output_type;
-```
-
-  - function_name：标量函数未来在 SQL 中被调用时的函数名，必须与函数实现中 udf 的实际名称一致；
-  - library_path：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
-  - output_type：此函数计算结果的数据类型名称；
-
-  例如，如下语句可以把 libbitand.so 创建为系统中可用的 UDF：
-
-  ```sql
-  CREATE FUNCTION bit_and AS "/home/taos/udf_example/libbitand.so" OUTPUTTYPE INT;
-  ```
-
-- 创建聚合函数：
-```sql
-CREATE AGGREGATE FUNCTION function_name AS library_path OUTPUTTYPE output_type [ BUFSIZE buffer_size ];
-```
-
-  - function_name：聚合函数未来在 SQL 中被调用时的函数名，必须与函数实现中 udfNormalFunc 的实际名称一致；
-  - library_path：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
-  - output_type：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
-  - buffer_size：中间计算结果的缓冲区大小，单位是字节。如果不使用可以不设置。
-
-  例如，如下语句可以把 libsqrsum.so 创建为系统中可用的 UDF：
-
-  ```sql
-  CREATE AGGREGATE FUNCTION sqr_sum AS "/home/taos/udf_example/libsqrsum.so" OUTPUTTYPE DOUBLE bufsize 8;
-  ```
-
-### 管理 UDF
-
-- 删除指定名称的用户定义函数：
-```
-DROP FUNCTION function_name;
-```
-
-- function_name：此参数的含义与 CREATE 指令中的 function_name 参数一致，也即要删除的函数的名字，例如 
-```sql
-DROP FUNCTION bit_and;
-```
-- 显示系统中当前可用的所有 UDF：
-```sql
-SHOW FUNCTIONS;
-```
-
-### 调用 UDF
-
-在 SQL 指令中，可以直接以在系统中创建 UDF 时赋予的函数名来调用用户定义函数。例如：
-```sql
-SELECT X(c1,c2) FROM table/stable;
-```
-
-表示对名为 c1, c2 的数据列调用名为 X 的用户定义函数。SQL 指令中用户定义函数可以配合 WHERE 等查询特性来使用。
-
+## 管理和使用UDF
+编译好的UDF，还需要将其加入到系统才能被正常的SQL调用。关于如何管理和使用UDF，参见[UDF使用说明](../12-taos-sql/26-udf.md)
 
 ## 示例代码
 
 ### 标量函数示例 [bit_and](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/bit_and.c)
 
+bit_add 实现多列的按位与功能。如果只有一列，返回这一列。bit_add 忽略空值。
+
 <details>
 <summary>bit_and.c</summary>
 
@@ -196,13 +231,15 @@ SELECT X(c1,c2) FROM table/stable;
 
 </details>
 
-### 聚合函数示例 [sqr_sum](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/sqr_sum.c)
+### 聚合函数示例 [l2norm](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/l2norm.c)
+
+l2norm 实现了输入列的所有数据的二阶范数，即对每个数据先平方，再累加求和，最后开方。
 
 <details>
-<summary>sqr_sum.c</summary>
+<summary>l2norm.c</summary>
 
 ```c
-{{#include tests/script/sh/sqr_sum.c}}
+{{#include tests/script/sh/l2norm.c}}
 ```
 
 </details>

docs/zh/10-deployment/01-deploy.md

@@ -73,11 +73,6 @@ serverPort            6030
 按照《立即开始》里的步骤，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos，启动 taos shell，从 shell 里执行命令“SHOW DNODES”，如下所示：
 
 ```
-Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
-Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
-
-Server is Enterprise trial Edition, ver:3.0.0.0 and will never expire.
-
 taos> show dnodes;
 id | endpoint | vnodes | support_vnodes | status | create_time | note |
 ============================================================================================================================================

docs/zh/10-deployment/05-helm.md

@@ -22,7 +22,7 @@ Helm 会使用 kubectl 和 kubeconfig 的配置来操作 Kubernetes，可以参
 TDengine Chart 尚未发布到 Helm 仓库，当前可以从 GitHub 直接下载：
 
 ```bash
-wget https://github.com/taosdata/TDengine-Operator/raw/main/helm/tdengine-0.3.0.tgz
+wget https://github.com/taosdata/TDengine-Operator/raw/3.0/helm/tdengine-3.0.0.tgz
 
 ```
 
@@ -38,7 +38,7 @@ kubectl get storageclass
 之后，使用 helm 命令安装：
 
 ```bash
-helm install tdengine tdengine-0.3.0.tgz \
+helm install tdengine tdengine-3.0.0.tgz \
   --set storage.className=<your storage class name>
 
 ```
@@ -46,7 +46,7 @@ helm install tdengine tdengine-0.3.0.tgz \
 在 minikube 环境下，可以设置一个较小的容量避免超出磁盘可用空间：
 
 ```bash
-helm install tdengine tdengine-0.3.0.tgz \
+helm install tdengine tdengine-3.0.0.tgz \
   --set storage.className=standard \
   --set storage.dataSize=2Gi \
   --set storage.logSize=10Mi
@@ -83,14 +83,14 @@ TDengine 支持 `values.yaml` 自定义。
 通过 helm show values 可以获取 TDengine Chart 支持的全部 values 列表：
 
 ```bash
-helm show values tdengine-0.3.0.tgz
+helm show values tdengine-3.0.0.tgz
 
 ```
 
 你可以将结果保存为 values.yaml，之后可以修改其中的各项参数，如 replica 数量，存储类名称，容量大小，TDengine 配置等，然后使用如下命令安装 TDengine 集群：
 
 ```bash
-helm install tdengine tdengine-0.3.0.tgz -f values.yaml
+helm install tdengine tdengine-3.0.0.tgz -f values.yaml
 
 ```
 
@@ -107,37 +107,17 @@ image:
   prefix: tdengine/tdengine
   #pullPolicy: Always
   # Overrides the image tag whose default is the chart appVersion.
-  #tag: "2.4.0.5"
+#  tag: "3.0.0.0"
 
 service:
   # ClusterIP is the default service type, use NodeIP only if you know what you are doing.
   type: ClusterIP
   ports:
     # TCP range required
-    tcp:
-      [
-        6030,
-        6031,
-        6032,
-        6033,
-        6034,
-        6035,
-        6036,
-        6037,
-        6038,
-        6039,
-        6040,
-        6041,
-        6042,
-        6043,
-        6044,
-        6045,
-        6060,
-      ]
-    # UDP range 6030-6039
-    udp: [6030, 6031, 6032, 6033, 6034, 6035, 6036, 6037, 6038, 6039]
-
-arbitrator: true
+    tcp: [6030, 6041, 6042, 6043, 6044, 6046, 6047, 6048, 6049, 6060]
+    # UDP range
+    udp: [6044, 6045]
+
 
 # Set timezone here, not in taoscfg
 timezone: "Asia/Shanghai"
@@ -182,11 +162,14 @@ clusterDomainSuffix: ""
 #
 # Btw, keep quotes "" around the value like below, even the value will be number or not.
 taoscfg:
+  # Starts as cluster or not, must be 0 or 1.
+  #   0: all pods will start as a seperate TDengine server
+  #   1: pods will start as TDengine server cluster. [default]
+  CLUSTER: "1"
+
   # number of replications, for cluster only
   TAOS_REPLICA: "1"
 
-  # number of management nodes in the system
-  TAOS_NUM_OF_MNODES: "1"
 
   # number of days per DB file
   # TAOS_DAYS: "10"
@@ -422,7 +405,7 @@ kubectl --namespace default exec $POD_NAME -- taos -s 'drop dnode "<you dnode in
 
 ```
 
-## 删除集群
+## 清理集群
 
 Helm 管理下，清理操作也变得简单：
 

docs/zh/12-taos-sql/02-database.md

@@ -112,9 +112,9 @@ alter_database_options:
 alter_database_option: {
     CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}
   | CACHESIZE value
-  | FSYNC value
+  | WAL_LEVEL value
+  | WAL_FSYNC_PERIOD value
   | KEEP value
-  | WAL value
 }
 ```
 

docs/zh/12-taos-sql/06-select.md

@@ -140,10 +140,6 @@ taos> SELECT ts, ts AS primary_key_ts FROM d1001;
 
 但是针对`first(*)`、`last(*)`、`last_row(*)`不支持针对单列的重命名。
 
-### 隐式结果列
-
-`Select_exprs`可以是表所属列的列名，也可以是基于列的函数表达式或计算式，数量的上限 256 个。当用户使用了`interval`或`group by tags`的子句以后，在最后返回结果中会强制返回时间戳列（第一列）和 group by 子句中的标签列。后续的版本中可以支持关闭 group by 子句中隐式列的输出，列输出完全由 select 子句控制。
-
 ### 伪列
 
 **TBNAME**
@@ -152,7 +148,13 @@ taos> SELECT ts, ts AS primary_key_ts FROM d1001;
 获取一个超级表所有的子表名及相关的标签信息：
 
 ```mysql
-SELECT TBNAME, location FROM meters;
+SELECT DISTINCT TBNAME, location FROM meters;
+```
+
+建议用户使用 INFORMATION_SCHEMA 下的 INS_TAGS 系统表来查询超级表的子表标签信息，例如获取超级表 meters 所有的子表名和标签值：
+
+```mysql
+SELECT table_name, tag_name, tag_type, tag_value FROM information_schema.ins_tags WHERE stable_name='meters';
 ```
 
 统计超级表下辖子表数量：

docs/zh/12-taos-sql/22-meta.md

 ---
-sidebar_label: 元数据库
-title: 元数据库
+sidebar_label: 元数据
+title: 存储元数据的 Information_Schema 数据库
 ---
 
 TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数据库元数据、数据库系统信息和状态的访问，例如数据库或表的名称，当前执行的 SQL 语句等。该数据库存储有关 TDengine 维护的所有其他数据库的信息。它包含多个只读表。实际上，这些表都是视图，而不是基表，因此没有与它们关联的文件。所以对这些表只能查询，不能进行 INSERT 等写入操作。`INFORMATION_SCHEMA` 数据库旨在以一种更一致的方式来提供对 TDengine 支持的各种 SHOW 语句（如 SHOW TABLES、SHOW DATABASES）所提供的信息的访问。与 SHOW 语句相比，使用 SELECT ... FROM INFORMATION_SCHEMA.tablename 具有以下优点：

docs/zh/14-reference/03-connector/_verify_linux.mdx

@@ -2,10 +2,6 @@
 
 ```text
 $ taos
-Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
-Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
-
-Server is Community Edition.
 
 taos> show databases;
               name              |       create_time       | vgroups |        ntables        | replica | strict |  duration  |              keep              |   buffer    |  pagesize   |    pages    |   minrows   |   maxrows   | comp | precision |   status   |           retention            | single_stable | cachemodel  |  cachesize  | wal_level | wal_fsync_period | wal_retention_period |  wal_retention_size   | wal_roll_period |     wal_seg_size      |