Merge branch 'fix/TD-5939' of github.com:taosdata/TDengine into fix/TD-5939

.gitmodules

@@ -19,3 +19,6 @@
 [submodule "src/plugins/blm3"]
 	path = src/plugins/blm3
 	url = https://github.com/taosdata/blm3
+[submodule "deps/avro"]
+	path = deps/avro
+	url = https://github.com/apache/avro

CMakeLists.txt

@@ -15,9 +15,30 @@ ELSE ()
   CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
 ENDIF ()
 
+if(NOT WIN32)
+  string(ASCII 27 Esc)
+  set(ColourReset "${Esc}[m")
+  set(ColourBold  "${Esc}[1m")
+  set(Red         "${Esc}[31m")
+  set(Green       "${Esc}[32m")
+  set(Yellow      "${Esc}[33m")
+  set(Blue        "${Esc}[34m")
+  set(Magenta     "${Esc}[35m")
+  set(Cyan        "${Esc}[36m")
+  set(White       "${Esc}[37m")
+  set(BoldRed     "${Esc}[1;31m")
+  set(BoldGreen   "${Esc}[1;32m")
+  set(BoldYellow  "${Esc}[1;33m")
+  set(BoldBlue    "${Esc}[1;34m")
+  set(BoldMagenta "${Esc}[1;35m")
+  set(BoldCyan    "${Esc}[1;36m")
+  set(BoldWhite   "${Esc}[1;37m")
+endif()
+
 SET(TD_ACCOUNT FALSE)
 SET(TD_ADMIN FALSE)
 SET(TD_GRANT FALSE)
+SET(TD_USB_DONGLE FALSE)
 SET(TD_MQTT FALSE)
 SET(TD_TSDB_PLUGINS FALSE)
 SET(TD_STORAGE FALSE)

Jenkinsfile

 import hudson.model.Result
 import hudson.model.*;
 import jenkins.model.CauseOfInterruption
-properties([pipelineTriggers([githubPush()])])
 node {
-    git url: 'https://github.com/taosdata/TDengine.git'
 }
 
 def skipbuild=0
@@ -113,6 +111,76 @@ def pre_test(){
     '''
     return 1
 }
+def pre_test_noinstall(){
+    sh'hostname'
+    sh'''
+    cd ${WKC}
+    git reset --hard HEAD~10 >/dev/null
+    '''
+    script {
+      if (env.CHANGE_TARGET == 'master') {
+        sh '''
+        cd ${WKC}
+        git checkout master
+        '''
+        }
+      else if(env.CHANGE_TARGET == '2.0'){
+        sh '''
+        cd ${WKC}
+        git checkout 2.0
+        '''
+      } 
+      else{
+        sh '''
+        cd ${WKC}
+        git checkout develop
+        '''
+      }
+    }
+    sh'''
+    cd ${WKC}
+    git pull >/dev/null
+    git fetch origin +refs/pull/${CHANGE_ID}/merge
+    git checkout -qf FETCH_HEAD
+    git clean -dfx
+    git submodule update --init --recursive
+    cd ${WK}
+    git reset --hard HEAD~10
+    '''
+    script {
+      if (env.CHANGE_TARGET == 'master') {
+        sh '''
+        cd ${WK}
+        git checkout master
+        '''
+        }
+      else if(env.CHANGE_TARGET == '2.0'){
+        sh '''
+        cd ${WK}
+        git checkout 2.0
+        '''
+      } 
+      else{
+        sh '''
+        cd ${WK}
+        git checkout develop
+        '''
+      } 
+    }
+    sh '''
+    cd ${WK}
+    git pull >/dev/null 
+    
+    export TZ=Asia/Harbin
+    date
+    git clean -dfx
+    mkdir debug
+    cd debug
+    cmake .. > /dev/null
+    make
+    '''
+    return 1
+}
 def pre_test_win(){
     bat '''
     taskkill /f /t /im python.exe
@@ -181,9 +249,9 @@ def pre_test_win(){
     git clean -dfx
     mkdir debug
     cd debug
-    call "C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat" amd64
+    call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\vcvarsall.bat" amd64
     cmake ../ -G "NMake Makefiles" 
-    nmake || exit 8
+    set CL=/MP nmake nmake || exit 8
     nmake install || exit 8
     xcopy /e/y/i/f C:\\workspace\\TDinternal\\debug\\build\\lib\\taos.dll C:\\Windows\\System32 || exit 8
     cd C:\\workspace\\TDinternal\\community\\src\\connector\\python
@@ -194,6 +262,7 @@ def pre_test_win(){
 }
 pipeline {
   agent none
+  options { skipDefaultCheckout() } 
   environment{
       WK = '/var/lib/jenkins/workspace/TDinternal'
       WKC= '/var/lib/jenkins/workspace/TDinternal/community'
@@ -201,6 +270,7 @@ pipeline {
   stages {
       stage('pre_build'){
           agent{label 'master'}
+          options { skipDefaultCheckout() } 
           when {
               changeRequest()
           }
@@ -209,59 +279,58 @@ pipeline {
               abort_previous()
               abortPreviousBuilds()
             }
-          sh'''
-          rm -rf ${WORKSPACE}.tes
-          cp -r ${WORKSPACE} ${WORKSPACE}.tes
-          cd ${WORKSPACE}.tes
-          git fetch
-          '''
-          script {
-            if (env.CHANGE_TARGET == 'master') {
-              sh '''
-              git checkout master
-              '''
-              }
-            else if(env.CHANGE_TARGET == '2.0'){
-              sh '''
-              git checkout 2.0
-              '''
-            } 
-            else{
-              sh '''
-              git checkout develop
-              '''
-            } 
-          }
-          sh'''
-          git fetch origin +refs/pull/${CHANGE_ID}/merge
-          git checkout -qf FETCH_HEAD
-          '''     
+          //   sh'''
+          // rm -rf ${WORKSPACE}.tes
+          // cp -r ${WORKSPACE} ${WORKSPACE}.tes
+          // cd ${WORKSPACE}.tes
+          // git fetch
+          // '''
+          // script {
+          //   if (env.CHANGE_TARGET == 'master') {
+          //     sh '''
+          //     git checkout master
+          //     '''
+          //     }
+          //   else if(env.CHANGE_TARGET == '2.0'){
+          //     sh '''
+          //     git checkout 2.0
+          //     '''
+          //   } 
+          //   else{
+          //     sh '''
+          //     git checkout develop
+          //     '''
+          //   } 
+          // }
+          // sh'''
+          // git fetch origin +refs/pull/${CHANGE_ID}/merge
+          // git checkout -qf FETCH_HEAD
+          // '''     
 
-          script{  
-            skipbuild='2'     
-            skipbuild=sh(script: "git log -2 --pretty=%B | fgrep -ie '[skip ci]' -e '[ci skip]' && echo 1 || echo 2", returnStdout:true)
-            println skipbuild
-          }
-          sh'''
-          rm -rf ${WORKSPACE}.tes
-          '''
+          // script{  
+          //   skipbuild='2'     
+          //   skipbuild=sh(script: "git log -2 --pretty=%B | fgrep -ie '[skip ci]' -e '[ci skip]' && echo 1 || echo 2", returnStdout:true)
+          //   println skipbuild
+          // }
+          // sh'''
+          // rm -rf ${WORKSPACE}.tes
+          // '''
+          // }       
           }
       }
       stage('Parallel test stage') {
         //only build pr
+        options { skipDefaultCheckout() } 
         when {
           allOf{
               changeRequest()
-               expression{
-                return skipbuild.trim() == '2'
-              }
+              not{ expression { env.CHANGE_BRANCH =~ /docs\// }}
             }
           }
       parallel {
         stage('python_1_s1') {
           agent{label " slave1 || slave11 "}
           steps {
-            
             pre_test()
             timeout(time: 55, unit: 'MINUTES'){
               sh '''
@@ -322,22 +391,10 @@ pipeline {
 
               '''
 
-              sh '''
-              cd ${WKC}/src/connector/node-rest/
-              npm install
-              npm run build 
-              npm run build:test
-              npm run test
-
-              '''
-
               sh '''
               cd ${WKC}/tests/examples/C#/taosdemo
               mcs -out:taosdemo *.cs > /dev/null 2>&1
               echo '' |./taosdemo -c /etc/taos
-                cd ${WKC}/tests/connectorTest/C#Test/nanosupport
-                mcs -out:nano *.cs > /dev/null 2>&1
-                echo '' |./nano
               '''
               sh '''
                 cd ${WKC}/tests/gotest
@@ -414,7 +471,7 @@ pipeline {
         stage('test_b4_s7') {
           agent{label " slave7 || slave17 "}
           steps {     
-            timeout(time: 55, unit: 'MINUTES'){       
+            timeout(time: 105, unit: 'MINUTES'){       
               pre_test()
               sh '''
               date
@@ -470,36 +527,90 @@ pipeline {
             }
           }
         } 
+        stage('arm64centos7') {
+          agent{label " arm64centos7 "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('arm64centos8') {
+          agent{label " arm64centos8 "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('arm32bionic') {
+          agent{label " arm32bionic "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('arm64bionic') {
+          agent{label " arm64bionic "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('arm64focal') {
+          agent{label " arm64focal "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('centos7') {
+          agent{label " centos7 "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('ubuntu:trusty') {
+          agent{label " trusty "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('ubuntu:xenial') {
+          agent{label " xenial "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
+        stage('ubuntu:bionic') {
+          agent{label " bionic "}
+          steps {     
+              pre_test_noinstall()    
+            }
+        }
 
-        // stage('build'){
-        //   agent{label " wintest "}
-        //   steps {
-        //     pre_test()
-        //     script{             
-        //         while(win_stop == 0){
-        //           sleep(1)
-        //           }
-        //       }
-        //     }
-        // }
-        // stage('test'){
-        //   agent{label "win"}
-        //   steps{
+        stage('build'){
+          agent{label " wintest "}
+          steps {
+            pre_test()
+            script{             
+                while(win_stop == 0){
+                  sleep(1)
+                  }
+              }
+            }
+        }
+        stage('test'){
+          agent{label "win"}
+          steps{
             
-        //     catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
-        //         pre_test_win()
-        //         timeout(time: 20, unit: 'MINUTES'){
-        //         bat'''
-        //         cd C:\\workspace\\TDinternal\\community\\tests\\pytest
-        //         .\\test-all.bat Wintest
-        //         '''
-        //         }
-        //     }     
-        //     script{
-        //       win_stop=1
-        //     }
-        //   }
-        // }
+            catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+                pre_test_win()
+                timeout(time: 20, unit: 'MINUTES'){
+                bat'''
+                cd C:\\workspace\\TDinternal\\community\\tests\\pytest
+                .\\test-all.bat wintest
+                '''
+                }
+            }     
+            script{
+              win_stop=1
+            }
+          }
+        }
           
                
     }

cmake/define.inc

@@ -13,6 +13,10 @@ IF (TD_GRANT)
   ADD_DEFINITIONS(-D_GRANT)
 ENDIF ()
 
+IF (TD_USB_DONGLE)
+  ADD_DEFINITIONS(-D_USB_DONGLE)
+ENDIF ()
+
 IF (TD_MQTT)
   ADD_DEFINITIONS(-D_MQTT)
 ENDIF ()
@@ -124,20 +128,38 @@ IF (TD_APLHINE)
   MESSAGE(STATUS "aplhine is defined")
 ENDIF ()
 
-IF (TD_LINUX)
+IF ("${BUILD_HTTP}" STREQUAL "")
+  IF (TD_LINUX)
     IF (TD_ARM_32)
-    SET(TD_BUILD_HTTP TRUE)
-    ADD_DEFINITIONS(-DHTTP_EMBEDDED)
+      SET(BUILD_HTTP "true")
     ELSE ()
-    IF (TD_BUILD_HTTP)
-      ADD_DEFINITIONS(-DHTTP_EMBEDDED)
+      SET(BUILD_HTTP "false")
     ENDIF ()
+  ELSE ()
+    SET(BUILD_HTTP "true")
   ENDIF ()
-ELSE ()
+ENDIF ()
+
+IF (${BUILD_HTTP} MATCHES "true")
   SET(TD_BUILD_HTTP TRUE)
+ELSEIF (${BUILD_HTTP} MATCHES "false")
+  SET(TD_BUILD_HTTP FALSE)
+ENDIF ()
+
+IF (TD_BUILD_HTTP)
   ADD_DEFINITIONS(-DHTTP_EMBEDDED)
 ENDIF ()
 
+IF ("${AVRO_SUPPORT}" MATCHES "true")
+  SET(TD_AVRO_SUPPORT TRUE)
+ELSEIF ("${AVRO_SUPPORT}" MATCHES "false")
+  SET(TD_AVRO_SUPPORT FALSE)
+ENDIF ()
+
+IF (TD_AVRO_SUPPORT)
+  ADD_DEFINITIONS(-DAVRO_SUPPORT)
+ENDIF ()
+
 IF (TD_LINUX)
   ADD_DEFINITIONS(-DLINUX)
   ADD_DEFINITIONS(-D_LINUX)

cmake/input.inc

@@ -92,9 +92,7 @@ ENDIF ()
 
 SET(TD_BUILD_HTTP FALSE)
 
-IF (${BUILD_HTTP} MATCHES "true")
-  SET(TD_BUILD_HTTP TRUE)
-ENDIF ()
+SET(TD_AVRO_SUPPORT FALSE)
 
 SET(TD_MEMORY_SANITIZER FALSE)
 IF (${MEMORY_SANITIZER} MATCHES "true")

cmake/install.inc

 IF (TD_LINUX)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
   INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
-  INSTALL(CODE "execute_process(COMMAND chmod 777 ${TD_MAKE_INSTALL_SH})")
-  INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR} Linux ${TD_VER_NUMBER})")
+  INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR} Linux ${TD_VER_NUMBER})")
 ELSEIF (TD_WINDOWS)
   IF (TD_POWER)
     SET(CMAKE_INSTALL_PREFIX C:/PowerDB)
@@ -36,11 +35,10 @@ ELSEIF (TD_WINDOWS)
   #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
   #INSTALL(TARGETS shell RUNTIME DESTINATION .)
   IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.35-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.36-dist.jar DESTINATION connector/jdbc)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
   INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
-  INSTALL(CODE "execute_process(COMMAND chmod 777 ${TD_MAKE_INSTALL_SH})")
-  INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR} Darwin ${TD_VER_NUMBER})")
+  INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR} Darwin ${TD_VER_NUMBER})")
 ENDIF ()

cmake/version.inc

@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.3.0.0")
+  SET(TD_VER_NUMBER "2.3.1.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

deps/CMakeLists.txt

@@ -25,10 +25,36 @@ IF (TD_DARWIN AND TD_MQTT)
   ADD_SUBDIRECTORY(MQTT-C)
 ENDIF ()
 
+IF (TD_AVRO_SUPPORT)
+  MESSAGE("")
+  MESSAGE("${Green} ENABLE avro format support ${ColourReset}")
+  MESSAGE("")
+  include(ExternalProject)
+  ExternalProject_Add(
+    apache-avro
+    PREFIX          "avro"
+    SOURCE_DIR      ${CMAKE_CURRENT_SOURCE_DIR}/avro/lang/c
+    BUILD_IN_SOURCE 1
+    PATCH_COMMAND
+        COMMAND   git clean -f -d
+        COMMAND   sed -i.bak -e "/TARGETS avroappend/d" ${CMAKE_CURRENT_SOURCE_DIR}/avro/lang/c/src/CMakeLists.txt
+        COMMAND   sed -i.bak -e "/TARGETS avrocat/d" ${CMAKE_CURRENT_SOURCE_DIR}/avro/lang/c/src/CMakeLists.txt
+        COMMAND   sed -i.bak -e "/TARGETS avromod/d" ${CMAKE_CURRENT_SOURCE_DIR}/avro/lang/c/src/CMakeLists.txt
+        COMMAND   sed -i.bak -e "/TARGETS avropipe/d" ${CMAKE_CURRENT_SOURCE_DIR}/avro/lang/c/src/CMakeLists.txt
+    CONFIGURE_COMMAND   cmake -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/build
+    )
+ELSE ()
+  MESSAGE("")
+  MESSAGE("${Yellow} NO avro format support ${ColourReset}")
+  MESSAGE("")
+ENDIF ()
+
 IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+  MESSAGE("")
+  MESSAGE("${Green} ENABLE jemalloc ${ColourReset}")
+  MESSAGE("")
   MESSAGE("setup deps/jemalloc, current source dir:" ${CMAKE_CURRENT_SOURCE_DIR})
   MESSAGE("binary dir:" ${CMAKE_BINARY_DIR})
-  include(ExternalProject)
   ExternalProject_Add(jemalloc
     PREFIX        "jemalloc"
     SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc

TSZ @ 0ca5b15a

-Subproject commit 0ca5b15a8eac40327dd737be52c926fa5675712c

avro @ a1fce29d

+Subproject commit a1fce29d9675b4dd95dfee9db32cc505d0b2227c

documentation20/cn/00.index/docs.md

@@ -81,6 +81,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [Node.js Connector](/connector#nodejs)：给node应用提供一个连接TDengine服务器的驱动
 * [C# Connector](/connector#csharp)：给C#应用提供一个连接TDengine服务器的驱动
 * [Windows客户端](https://www.taosdata.com/blog/2019/07/26/514.html)：自行编译windows客户端，Windows环境的各种连接器都需要它
+* [Rust Connector](/connector/rust): Rust语言下通过libtaos客户端或RESTful接口，连接TDengine服务器。
 
 ## [与其他工具的连接](/connections)
 
@@ -131,7 +132,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [TDengine写入性能测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
 * [IDEA数据库管理工具可视化使用TDengine](https://www.taosdata.com/blog/2020/08/27/1767.html)
 * [基于Electron开发的跨平台TDengine图形化管理工具](https://github.com/skye0207/TDengineGUI)
-* [DataX，支持TDengine的离线数据采集/同步工具](https://github.com/wgzhao/DataX)（文档：[读取插件](https://github.com/wgzhao/DataX/blob/master/docs/src/main/sphinx/reader/tdenginereader.md)、[写入插件](https://github.com/wgzhao/DataX/blob/master/docs/src/main/sphinx/writer/tdenginewriter.md)）
+* [基于DataX的TDeninge数据迁移工具](https://www.taosdata.com/blog/2021/10/26/3156.html)
 
 ## TDengine与其他数据库的对比测试
 

documentation20/cn/03.architecture/docs.md

@@ -382,17 +382,17 @@ dataDir [path] <level> <primary>
    各级存储之间的数据流向：0 级存储 -> 1 级存储 -> 2 级存储。   
    同一存储等级可挂载多个硬盘，同一存储等级上的数据文件分布在该存储等级的所有硬盘上。   
    需要说明的是，数据在不同级别的存储介质上的移动，是由系统自动完成的，用户无需干预。
--  primary: 是否为主挂载点，0（是）或 1（否），省略默认为 1。
+-  primary: 是否为主挂载点，0（否）或 1（是），省略默认为 1。
 
-在配置中，只允许一个主挂载点的存在（level=0, primary=0），例如采用如下的配置方式：
+在配置中，只允许一个主挂载点的存在（level=0, primary=1），例如采用如下的配置方式：
 
 ```
-dataDir /mnt/data1 0 0
-dataDir /mnt/data2 0 1
-dataDir /mnt/data3 1 1
-dataDir /mnt/data4 1 1
-dataDir /mnt/data5 2 1
-dataDir /mnt/data6 2 1
+dataDir /mnt/data1 0 1
+dataDir /mnt/data2 0 0
+dataDir /mnt/data3 1 0
+dataDir /mnt/data4 1 0
+dataDir /mnt/data5 2 0
+dataDir /mnt/data6 2 0
 ```
 
 注意：

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

@@ -334,7 +334,6 @@ JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（
 从 2.1.2.0 版本开始，TDengine 的 **JDBC-JNI** 实现大幅改进了参数绑定方式对数据写入（INSERT）场景的支持。采用这种方式写入数据时，能避免 SQL 语法解析的资源消耗，从而在很多情况下显著提升写入性能。（注意：**JDBC-RESTful** 实现并不提供参数绑定这种使用方式。）
 
 ```java
-Statement stmt = conn.createStatement();
 Random r = new Random();
 
 // INSERT 语句中，VALUES 部分允许指定具体的数据列；如果采取自动建表，则 TAGS 部分需要设定全部 TAGS 列的参数值：

documentation20/cn/08.connector/02.rust/docs.md

+# Rust 连接器
+
+![Crates.io](https://img.shields.io/crates/v/libtaos) ![Crates.io](https://img.shields.io/crates/d/libtaos)
+
+> Rust 连接器仍然在快速开发中，版本API变动在所难免，在1.0 之前无法保证其向后兼容，请使用时注意版本及对应的文档。
+
+感谢 [@songtianyi](https://github.com/songtianyi) 对 [libtdengine](https://github.com/songtianyi/tdengine-rust-bindings) 的贡献，使Rust社区能够使用Rust 连接[TDengine]. [libtaos-rs] 项目旨在为Rust开发者提供官方支持，使用taosc接口及HTTP接口构建兼容API以便于用户切换接口方式。
+
+## 依赖
+
+- [Rust](https://www.rust-lang.org/learn/get-started)
+
+默认情况下，[libtaos-rs] 使用 C 接口连接数据库，所以您需要：
+
+- [TDengine] [客户端](https://www.taosdata.com/cn/getting-started/#%E9%80%9A%E8%BF%87%E5%AE%89%E8%A3%85%E5%8C%85%E5%AE%89%E8%A3%85)
+- `clang`: `bindgen` 使用 `libclangAST` 来生成对应的Rust绑定。
+
+## 特性列表
+
+- [x] C 接口的Rust绑定
+- [x] 使用 `rest` feature 来启用 RESTful API.
+- [x] [r2d2] 连接池支持（feature `r2d2`）
+- [ ] 迭代器接口
+- [ ] 流式计算接口
+- [ ] 订阅支持
+
+## 构建和测试
+
+```sh
+cargo build
+cargo test
+```
+
+测试使用默认用户名密码和本地连接。您可以根据具体情况设置环境变量：
+
+- `TEST_TAOS_IP`
+- `TEST_TAOS_PORT`
+- `TEST_TAOS_USER`
+- `TEST_TAOS_PASS`
+- `TEST_TAOS_DB`
+
+## 使用
+
+使用默认的taosc 连接方式，可以在 `Cargo.toml` 中直接添加 `libtaos` 依赖：
+
+```toml
+[dependencies]
+libtaos = "v0.3.8"
+```
+
+添加 feature `r2d2` 来启动连接池：
+
+```toml
+[dependencies]
+libtaos = { version = "*", features = ["r2d2"] }
+```
+
+对于RESTful接口，可使用 `rest` 特性来替代taosc，免去安装TDengine客户端。
+
+```toml
+[dependencies]
+libtaos = { version = "*", features = ["rest"] }
+```
+
+本项目中提供一个 [示例程序]([examples/demo.rs](https://github.com/taosdata/libtaos-rs/blob/main/examples/demo.rs)) 如下：
+
+```rust
+// ...
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    init();
+    let taos = taos_connect()?;
+
+    assert_eq!(
+        taos.query("drop database if exists demo").await.is_ok(),
+        true
+    );
+    assert_eq!(taos.query("create database demo").await.is_ok(), true);
+    assert_eq!(taos.query("use demo").await.is_ok(), true);
+    assert_eq!(
+        taos.query("create table m1 (ts timestamp, speed int)")
+            .await
+            .is_ok(),
+        true
+    );
+
+    for i in 0..10i32 {
+        assert_eq!(
+            taos.query(format!("insert into m1 values (now+{}s, {})", i, i).as_str())
+                .await
+                .is_ok(),
+            true
+        );
+    }
+    let rows = taos.query("select * from m1").await?;
+
+    println!("{}", rows.column_meta.into_iter().map(|col| col.name).join(","));
+    for row in rows.rows {
+        println!("{}", row.into_iter().join(","));
+    }
+    Ok(())
+}
+```
+
+您可以在 [bailongma-rs] - 一个 Rust 编写的 Prometheus 远程存储 API 适配器 - 看到如何在具体应用中使用 Rust 连接器。
+
+[libtaos-rs]: https://github.com/taosdata/libtaos-rs
+[TDengine]: https://github.com/taosdata/TDengine
+[bailongma-rs]: https://github.com/taosdata/bailongma-rs
+[r2d2]: https://crates.io/crates/r2d2
\ No newline at end of file

documentation20/cn/08.connector/docs.md

@@ -407,43 +407,43 @@ typedef struct TAOS_MULTI_BIND {
 
 除了使用 SQL 方式或者使用参数绑定 API 写入数据外，还可以使用 Schemaless 的方式完成写入。Schemaless 可以免于预先创建超级表/数据子表的数据结构，而是可以直接写入数据，TDengine 系统会根据写入的数据内容自动创建和维护所需要的表结构。Schemaless 的使用方式详见 [Schemaless 写入](https://www.taosdata.com/cn/documentation/insert#schemaless) 章节，这里介绍与之配套使用的 C/C++ API。  
 
-2.2.0.0版本接口：
-- `int taos_insert_lines(TAOS* taos, char* lines[], int numLines)`
+- `TAOS_RES* taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, int precision)`
   
-  以 Schemaless 格式写入多行数据。其中：
-    * taos：调用 taos_connect 返回的数据库连接。
-    * lines：由 char 字符串指针组成的数组，指向本次想要写入数据库的多行数据。
-    * numLines：lines 数据的总行数。 
+  **功能说明**  
+    该接口将行协议的文本数据写入到TDengine中。
     
-  返回值为 0 表示写入成功，非零值表示出错。具体错误代码请参见 [taoserror.h](https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h) 文件。
-
-  说明：
-    1. 此接口是一个同步阻塞式接口，使用时机与 `taos_query()` 一致。
-    2. 在调用此接口之前，必须先调用 `taos_select_db()` 来确定目前是在向哪个 DB 来写入。
-
-2.3.0.0版本接口：
-- `int taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, const char* precision, int* affectedRows, char* msg, int msgBufLen)`
   **参数说明**  
     taos:  数据库连接，通过taos_connect 函数建立的数据库连接。  
     lines：文本数据。满足解析格式要求的无模式文本字符串。  
     numLines:文本数据的行数，不能为 0 。  
     protocol: 行协议类型，用于标识文本数据格式。  
     precision：文本数据中的时间戳精度字符串。  
-    affectedRows：插入操作完成以后，正确写入到数据库中的记录行数。
-    msg: 如果出现错误（函数返回值不为 0）情况下，错误提示信息。该参数是输入参数，需要用户指定消息输出缓冲区，如果不指定该缓冲区（输入为NULL），即使出现错误也不会得到错误提示信息。
-    msgBufLen: 缓冲区的长度，避免错误提示消息越界。
     
   **返回值**  
-    0：无错误发生。
-    非 0 值：发生了错误。此时可以通过msg获取错误信息的提示。该返回值含义可以参考taoserror.h文件中的错误码定义。
+    TAOS_RES 结构体，应用可以通过使用 taos_errstr 获得错误信息，也可以使用 taos_errno 获得错误码。  
+    在某些情况下，返回的 TAOS_RES 为 NULL，此时仍然可以调用 taos_errno 来安全地获得错误码信息。  
+    返回的 TAOS_RES 需要调用方来负责释放，否则会出现内存泄漏。  
       
   **说明**  
     协议类型是枚举类型，包含以下三种格式：  
-    SML_LINE_PROTOCOL：InfluxDB行协议（Line Protocol)
-    SML_TELNET_PROTOCOL: OpenTSDB文本行协议
-    SML_JSON_PROTOCOL: OpenTSDB Json协议格式
+    TSDB_SML_LINE_PROTOCOL：InfluxDB行协议（Line Protocol)  
+    TSDB_SML_TELNET_PROTOCOL: OpenTSDB文本行协议  
+    TSDB_SML_JSON_PROTOCOL: OpenTSDB Json协议格式  
+    
+    时间戳分辨率的定义，定义在 taos.h 文件中，具体内容如下：  
+    TSDB_SML_TIMESTAMP_NOT_CONFIGURED = 0,  
+    TSDB_SML_TIMESTAMP_HOURS,  
+    TSDB_SML_TIMESTAMP_MINUTES,  
+    TSDB_SML_TIMESTAMP_SECONDS,  
+    TSDB_SML_TIMESTAMP_MILLI_SECONDS,  
+    TSDB_SML_TIMESTAMP_MICRO_SECONDS,  
+    TSDB_SML_TIMESTAMP_NANO_SECONDS  
+    
+    需要注意的是，时间戳分辨率参数只在协议类型为 SML_LINE_PROTOCOL 的时候生效。  
+    对于 OpenTSDB 的文本协议，时间戳的解析遵循其官方解析规则 — 按照时间戳包含的字符的数量来确认时间精度。
     
-    时间戳分辨率的说明使用如下字符串：“h“ （小时）、”m“（分钟）、”s“ （秒） ”ms“（毫秒）、”u“ (微秒）、”ns”（纳秒），不区分大小写。需要注意的是，时间戳分辨率参数只在协议类型为 SML_LINE_PROTOCOL 的时候生效。对于 OpenTSDB的文本协议，时间戳的解析遵循其官方解析规则 — 按照时间戳包含的字符的数量来确认时间精度。
+  **支持版本**  
+    该功能接口从2.3.0.0版本开始支持。
   
 ```c
 #include <stdlib.h>
@@ -455,9 +455,6 @@ int main() {
   const char* user = "root";
   const char* passwd = "taosdata";
     
-  // error message buffer
-  char msg[512] = {0};
-   
   // connect to server
   TAOS* taos = taos_connect(host, user, passwd, "test", 0);
    
@@ -468,17 +465,18 @@ int main() {
   };
  
   // schema-less insert
-  int code = taos_schemaless_insert(taos, lines1, 2, SML_LINE_PROTOCOL, "ns", msg, sizeof(msg)/sizeof(msg[0]));
-  if (code != 0) {
-    printf("failed to insert schema-less data, reason: %s\n", msg);
+  TAOS_RES* res = taos_schemaless_insert(taos, lines1, 2, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
   }
  
+  taos_free_result(res);
+ 
   // close the connection
   taos_close(taos);
   return (code);
 }
 ```
-**注**：后续2.2.0.0版本也更新成2.3.0.0版本的接口。
 
 ### 连续查询接口
 
@@ -575,6 +573,14 @@ cd C:\TDengine\connector\python
 python -m pip install .
 ```
 
+**PyPI**
+
+从2.1.1版本开始，用户可以从[PyPI](https://pypi.org/project/taospy/)安装：
+
+```sh
+pip install taospy
+```
+
 * 如果机器上没有pip命令，用户可将src/connector/python下的taos文件夹拷贝到应用程序的目录使用。
 对于windows 客户端，安装TDengine windows 客户端后，将C:\TDengine\driver\taos.dll拷贝到C:\windows\system32目录下即可。
 
@@ -610,6 +616,22 @@ python3 PythonChecker.py -host <fqdn>
 
 ### Python连接器的使用
 
+#### PEP-249 兼容API
+
+您可以像其他数据库一样，使用类似 [PEP-249](https://www.python.org/dev/peps/pep-0249/) 数据库API规范风格的API：
+
+```python
+import taos
+
+conn = taos.connect()
+cursor = conn.cursor()
+
+cursor.execute("show databases")
+results = cursor.fetchall()
+for row in results:
+    print(row)
+```
+
 #### 代码示例
 
 * 导入TDengine客户端模块
@@ -665,6 +687,44 @@ for data in c1:
   print("ts=%s, temperature=%d, humidity=%f" %(data[0], data[1],data[2]))
 ```
 
+* 从v2.1.0版本开始, 我们提供另外一种API：`connection.query`
+
+    ```python
+    import taos
+
+    conn = taos.connect()
+    conn.execute("create database if not exists pytest")
+
+    result = conn.query("show databases")
+    num_of_fields = result.field_count
+    for field in result.fields:
+        print(field)
+    for row in result:
+        print(row)
+    conn.execute("drop database pytest")
+    ```
+
+    `query` 方法会返回一个 `TaosResult` 类对象，并提供了以下有用的属性或方法:
+
+    属性:
+
+    - `fields`: `TaosFields` 集合类，提供返回数据的列信息。
+    - `field_count`: 返回数据的列数.
+    - `affected_rows`: 插入数据的行数.
+    - `row_count`: 查询数据结果数.
+    - `precision`: 当前数据库的时间精度.
+
+    方法:
+
+    - `fetch_all()`: 类似于 `cursor.fetchall()` 返回同样的集合数据
+    - `fetch_all_into_dict()`: v2.1.1 新添加的API，将上面的数据转换成字典类型返回
+    - `blocks_iter()` `rows_iter()`: 根据底层API提供的两种不同迭代器。
+    - `fetch_rows_a`: 异步API
+    - `errno`: 错误码
+    - `errstr`: 错误信息
+    - `close`: 关闭结果对象，一般不需要直接调用
+
+
 * 创建订阅
 
 ```python

documentation20/cn/09.connections/docs.md

@@ -3,7 +3,7 @@
 
 ## <a class="anchor" id="grafana"></a>Grafana
 
-TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/)快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine 中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。
+TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/)快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine 中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。关于TDengine插件的使用您可以在[GitHub](https://github.com/taosdata/grafanaplugin/blob/master/README.md)中了解更多。
 
 ### 安装Grafana
 
@@ -11,19 +11,24 @@ TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/
 
 ### 配置Grafana
 
-TDengine 的 Grafana 插件在安装包的 /usr/local/taos/connector/grafanaplugin 目录下。
-
-以 CentOS 7.2 操作系统为例，将 grafanaplugin 目录拷贝到 /var/lib/grafana/plugins 目录下，重新启动 grafana 即可。
+TDengine 的 Grafana 插件请从 <https://github.com/taosdata/grafanaplugin/releases/latest> 下载。
 
 ```bash
-sudo cp -rf /usr/local/taos/connector/grafanaplugin /var/lib/grafana/plugins/tdengine
+GF_VERSION=3.1.1
+wget https://github.com/taosdata/grafanaplugin/releases/download/v$GF_VERSION/tdengine-datasource-$GF_VERSION.zip
 ```
 
-Grafana 8.x 版本会对插件进行签名检查，因此还需要在 grafana.ini 文件中增加如下行，才能正确使用插件：
+以 CentOS 7.2 操作系统为例，将插件包解压到 /var/lib/grafana/plugins 目录下，重新启动 grafana 即可。
+
+```bash
+sudo unzip tdengine-datasource-$GF_VERSION.zip -d /var/lib/grafana/plugins/
 ```
+
+Grafana 7.3+ / 8.x 版本会对插件进行签名检查，因此还需要在 grafana.ini 文件中增加如下行，才能正确使用插件：
+
+```ini
 [plugins]
-enable_alpha = true
-allow_loading_unsigned_plugins = taosdata-tdengine-datasource
+allow_loading_unsigned_plugins = tdengine-datasource
 ```
 
 ### 使用 Grafana
@@ -62,7 +67,6 @@ allow_loading_unsigned_plugins = taosdata-tdengine-datasource
 * ALIAS BY：可设置当前查询别名。 
 * GENERATE SQL： 点击该按钮会自动替换相应变量，并生成最终执行的语句。
   
-
 按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：
 
 ![img](../images/connections/create_dashboard2.jpg)
@@ -71,16 +75,15 @@ allow_loading_unsigned_plugins = taosdata-tdengine-datasource
 
 #### 导入 Dashboard
 
-在 Grafana 插件目录 /usr/local/taos/connector/grafanaplugin/dashboard 下提供了一个 `tdengine-grafana.json` 可导入的 dashboard。
+我们提供一个 TDengine Dashboard 可以作为 TDengine 集群的监控可视化工具使用，见 [Grafana Dashboard 15146](https://grafana.com/grafana/dashboards/15146)。
 
-点击左侧 `Import` 按钮，并上传 `tdengine-grafana.json` 文件：
+点击左侧 `Import` 按钮，选择 **Grafana.com Dashboard**,j将id `15146` 填入并加载：
 
 ![img](../images/connections/import_dashboard1.jpg)
 
 导入完成之后可看到如下效果：
 
-![img](../images/connections/import_dashboard2.jpg)
-
+![img](../images/connections/dashboard-15146.png)
 
 ## <a class="anchor" id="matlab"></a>MATLAB
 

documentation20/cn/12.taos-sql/02.udf/docs.md

 # UDF（用户定义函数）
 
-在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。
+在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。 UDF 通常以数据表中的一列数据做为输入，同时支持以嵌套子查询的结果作为输入。
 
 从 2.2.0.0 版本开始，TDengine 支持通过 C/C++ 语言进行 UDF 定义。接下来结合示例讲解 UDF 的使用方法。
 
@@ -9,76 +9,70 @@
 TDengine 提供 3 个 UDF 的源代码示例，分别为：
 * [add_one.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c)
 * [abs_max.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/abs_max.c)
-* [sum_double.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/sum_double.c)
+* [demo.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/demo.c)
 
-### 无需中间变量的标量函数
+### 标量函数
 
 [add_one.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c) 是结构最简单的 UDF 实现。其功能为：对传入的一个数据列（可能因 WHERE 子句进行了筛选）中的每一项，都输出 +1 之后的值，并且要求输入的列数据类型为 INT。 
 
-这一具体的处理逻辑在函数 `void add_one(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBUf, char* tsOutput, int* numOfOutput, short otype, short obytes, SUdfInit* buf)` 中定义。这类用于实现 UDF 的基础计算逻辑的函数，我们称为 udfNormalFunc，也就是对行数据块的标量计算函数。需要注意的是，udfNormalFunc 的参数项是固定的，用于按照约束完成与引擎之间的数据交换。
+这一具体的处理逻辑在函数 `void add_one(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput, int* numOfOutput, short otype, short obytes, SUdfInit* buf)` 中定义。这类用于实现 UDF 的基础计算逻辑的函数，我们称为 udfNormalFunc，也就是对行数据块的标量计算函数。需要注意的是，udfNormalFunc 的参数项是固定的，用于按照约束完成与引擎之间的数据交换。
 
 - udfNormalFunc 中各参数的具体含义是：
-  * data：存有输入的数据。
+  * data：输入数据。
   * itype：输入数据的类型。这里采用的是短整型表示法，与各种数据类型对应的值可以参见 [column_meta 中的列类型说明](https://www.taosdata.com/cn/documentation/connector#column_meta)。例如 4 用于表示 INT 型。
   * iBytes：输入数据中每个值会占用的字节数。
   * numOfRows：输入数据的总行数。
-  * ts：主键时间戳在输入中的列数据。
-  * dataOutput：输出数据的缓冲区。
-  * interBuf：系统使用的中间临时缓冲区，通常用户逻辑无需对 interBuf 进行处理。
-  * tsOutput：主键时间戳在输出时的列数据。
-  * numOfOutput：输出数据的个数。
+  * ts：主键时间戳在输入中的列数据(只读)。
+  * dataOutput：输出数据的缓冲区，缓冲区大小为用户指定的输出类型大小 * numOfRows。
+  * interBuf：中间计算结果的缓冲区，大小为用户在创建 UDF 时指定的BUFSIZE大小。通常用于计算中间结果与最终结果不一致时使用，由引擎负责分配与释放。
+  * tsOutput：主键时间戳在输出时的列数据，如果非空可用于输出结果对应的时间戳。
+  * numOfOutput：输出结果的个数（行数）。
   * oType：输出数据的类型。取值含义与 itype 参数一致。
-  * oBytes：输出数据中每个值会占用的字节数。
-  * buf：计算过程的中间变量缓冲区。
+  * oBytes：输出数据中每个值占用的字节数。
+  * buf：用于在 UDF 与引擎间的状态控制信息传递块。
 
-其中 buf 参数需要用到一个自定义结构体 SUdfInit。在这个例子中，因为 add_one 的计算过程无需用到中间变量缓存，所以可以把 SUdfInit 定义成一个空结构体。
 
-### 无需中间变量的聚合函数
+### 聚合函数
 
 [abs_max.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/abs_max.c) 实现的是一个聚合函数，功能是对一组数据按绝对值取最大值。
 
-其计算过程为：与所在查询语句相关的数据会被分为多个行数据块，对每个行数据块调用 udfNormalFunc（在本例的实现代码中，实际函数名是 `abs_max`)，再将每个数据块的计算结果调用 udfMergeFunc（本例中，其实际的函数名是 `abs_max_merge`）进行聚合，生成每个子表的聚合结果。如果查询指令涉及超级表，那么最后还会通过 udfFinalizeFunc（本例中，其实际的函数名是 `abs_max_finalize`）再把子表的计算结果聚合为超级表的计算结果。
+其计算过程为：与所在查询语句相关的数据会被分为多个行数据块，对每个行数据块调用 udfNormalFunc（在本例的实现代码中，实际函数名是 `abs_max`)来生成每个子表的中间结果，再将子表的中间结果调用 udfMergeFunc（本例中，其实际的函数名是 `abs_max_merge`）进行聚合，生成超级表的最终聚合结果或中间结果。聚合查询最后还会通过 udfFinalizeFunc（本例中，其实际的函数名是 `abs_max_finalize`）再把超级表的中间结果处理为最终结果，最终结果只能含0或1条结果数据。
 
 值得注意的是，udfNormalFunc、udfMergeFunc、udfFinalizeFunc 之间，函数名约定使用相同的前缀，此前缀即 udfNormalFunc 的实际函数名。udfMergeFunc 的函数名后缀 `_merge`、udfFinalizeFunc 的函数名后缀 `_finalize`，是 UDF 实现规则的一部分，系统会按照这些函数名后缀来调用相应功能。
 
-- udfMergeFunc 用于对计算中间结果进行聚合。本例中 udfMergeFunc 对应的实现函数为 `void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
-  * data：udfNormalFunc 的输出组合在一起的数据，也就成为了 udfMergeFunc 的输入。
+- udfMergeFunc 用于对计算中间结果进行聚合，只有针对超级表的聚合查询才需要调用该函数。本例中 udfMergeFunc 对应的实现函数为 `void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
+  * data：udfNormalFunc 的输出数据数组，如果使用了 interBuf 那么 data 就是 interBuf 的数组。
   * numOfRows：data 中数据的行数。
-  * dataOutput：输出数据的缓冲区。
-  * numOfOutput：输出数据的个数。
-  * buf：计算过程的中间变量缓冲区。
-
-- udfFinalizeFunc 用于对计算结果进行最终聚合。本例中 udfFinalizeFunc 对应的实现函数为 `void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
-  * dataOutput：输出数据的缓冲区。对 udfFinalizeFunc 来说，其输入数据也来自于这里。
-  * interBuf：系统使用的中间临时缓冲区，与 udfNormalFunc 中的同名参数含义一致。
-  * numOfOutput：输出数据的个数。
-  * buf：计算过程的中间变量缓冲区。
-
-同样因为 abs_max 的计算过程无需用到中间变量缓存，所以同样是可以把 SUdfInit 定义成一个空结构体。
+  * dataOutput：输出数据的缓冲区，大小等于一条最终结果的大小。如果此时输出还不是最终结果，可以选择输出到 interBuf 中即data中。
+  * numOfOutput：输出结果的个数（行数）。
+  * buf：用于在 UDF 与引擎间的状态控制信息传递块。
 
-### 使用中间变量的聚合函数
+- udfFinalizeFunc 用于对计算结果进行最终计算，通常用于有 interBuf 使用的场景。本例中 udfFinalizeFunc 对应的实现函数为 `void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
+  * dataOutput：输出数据的缓冲区。
+  * interBuf：中间结算结果缓冲区，可作为输入。
+  * numOfOutput：输出数据的个数，对聚合函数来说只能是0或者1。
+  * buf：用于在 UDF 与引擎间的状态控制信息传递块。
 
-[sum_double.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/sum_double.c) 也是一个聚合函数，功能是对一组数据输出求和结果的倍数。
 
-出于功能演示的目的，在这个用户定义函数的实现方法中，用到了中间变量缓冲区 buf。因此，在这个源代码文件中，SUdfInit 就不再是一个空的结构体，而是定义了缓冲区的具体存储内容。
+### 其他 UDF 函数
 
-也正是因为用到了中间变量缓冲区，因此就需要对这一缓冲区进行初始化和资源释放。具体来说，也即对应 udfInitFunc（本例中，其实际的函数名是 `sum_double_init`）和 udfDestroyFunc（本例中，其实际的函数名是 `sum_double_destroy`）。其函数名命名规则同样是采取以 udfNormalFunc 的实际函数名为前缀，以 `_init` 和 `_destroy` 为后缀。系统会在初始化和资源释放时调用对应名称的函数。
+用户 UDF 程序除了需要实现上面几个函数外，还有两个用于初始化和释放 UDF 与引擎间的状态控制信息传递块的函数。具体来说，也即对应 udfInitFunc 和 udfDestroyFunc。其函数名命名规则同样是采取以 udfNormalFunc 的实际函数名为前缀，以 `_init` 和 `_destroy` 为后缀。系统会在初始化和资源释放时调用对应名称的函数。
 
-- udfInitFunc 用于初始化中间变量缓冲区中的变量和内容。本例中 udfInitFunc 对应的实现函数为 `int sum_double_init(SUdfInit* buf)`，其中各参数的具体含义是：
-  * buf：计算过程的中间变量缓冲区。
+- udfInitFunc 用于初始化状态控制信息传递块。上例中 udfInitFunc 对应的实现函数为 `int abs_max_init(SUdfInit* buf)`，其中各参数的具体含义是：
+  * buf：用于在  UDF 与引擎间的状态控制信息传递块。
 
-- udfDestroyFunc 用于释放中间变量缓冲区中的变量和内容。本例中 udfDestroyFunc 对应的实现函数为 `void sum_double_destroy(SUdfInit* buf)`，其中各参数的具体含义是：
-  * buf：计算过程的中间变量缓冲区。
+- udfDestroyFunc 用于释放状态控制信息传递块。上例中 udfDestroyFunc 对应的实现函数为 `void abs_max_destroy(SUdfInit* buf)`，其中各参数的具体含义是：
+  * buf：用于在  UDF 与引擎间的状态控制信息传递块。
 
-注意，UDF 的实现过程中需要小心处理对中间变量缓冲区的使用，如果使用不当则有可能导致内存泄露或对资源的过度占用，甚至导致系统服务进程崩溃等。
+目前该功能暂时没有实际意义，待后续扩展使用。
 
 ### UDF 实现方式的规则总结
 
-根据所要实现的 UDF 类型不同，用户所要实现的功能函数内容也会有所区别：
-* 无需中间变量的标量函数：结构体 SUdfInit 可以为空，需实现 udfNormalFunc。
-* 无需中间变量的聚合函数：结构体 SUdfInit 可以为空，需实现 udfNormalFunc、udfMergeFunc、udfFinalizeFunc。
-* 使用中间变量的标量函数：结构体 SUdfInit 需要具体定义，并需实现 udfNormalFunc、udfInitFunc、udfDestroyFunc。
-* 使用中间变量的聚合函数：结构体 SUdfInit 需要具体定义，并需实现 udfNormalFunc、udfInitFunc、udfDestroyFunc、udfMergeFunc、udfFinalizeFunc。
+根据 UDF 函数类型的不同，用户所要实现的功能函数也不同：
+* 标量函数：UDF 中需实现 udfNormalFunc。
+* 聚合函数：UDF 中需实现 udfNormalFunc、udfMergeFunc（对超级表查询）、udfFinalizeFunc。
+
+需要注意的是，如果对应的函数不需要具体的功能，也需要实现一个空函数。
 
 ## 编译 UDF
 
@@ -97,28 +91,30 @@ gcc -g -O0 -fPIC -shared add_one.c -o add_one.so
 
 用户可以通过 SQL 指令在系统中加载客户端所在主机上的 UDF 函数库（不能通过 RESTful 接口或 HTTP 管理界面来进行这一过程）。一旦创建成功，则当前 TDengine 集群的所有用户都可以在 SQL 指令中使用这些函数。UDF 存储在系统的 MNode 节点上，因此即使重启 TDengine 系统，已经创建的 UDF 也仍然可用。
 
-在创建 UDF 时，需要区分标量函数和聚合函数。如果创建时声明了错误的函数类别，则可能导致通过 SQL 指令调用函数时出错。
+在创建 UDF 时，需要区分标量函数和聚合函数。如果创建时声明了错误的函数类别，则可能导致通过 SQL 指令调用函数时出错。此外， UDF 支持输入与输出类型不一致，用户需要保证输入数据类型与 UDF 程序匹配，UDF 输出数据类型与 OUTPUTTYPE 匹配。
 
-- 创建标量函数：`CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize B;`
+- 创建标量函数：`CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) [ BUFSIZE B ];`
   * ids(X)：标量函数未来在 SQL 指令中被调用时的函数名，必须与函数实现中 udfNormalFunc 的实际名称一致；
-  * ids(Y)：包含 UDF 函数实现的动态链接库的库文件路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
+  * ids(Y)：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
   * typename(Z)：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
-  * B：系统使用的中间临时缓冲区大小，单位是字节，最小 0，最大 512，通常可以设置为 128。
+  * B：中间计算结果的缓冲区大小，单位是字节，最小 0，最大 512，如果不使用可以不设置。
 
   例如，如下语句可以把 add_one.so 创建为系统中可用的 UDF：
   ```sql
   CREATE FUNCTION add_one AS "/home/taos/udf_example/add_one.so" OUTPUTTYPE INT;
   ```
 
-- 创建聚合函数：`CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize B;`
+- 创建聚合函数：`CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) [ BUFSIZE B ];`
   * ids(X)：聚合函数未来在 SQL 指令中被调用时的函数名，必须与函数实现中 udfNormalFunc 的实际名称一致；
-  * ids(Y)：包含 UDF 函数实现的动态链接库的库文件路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
+  * ids(Y)：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
   * typename(Z)：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
-  * B：系统使用的中间临时缓冲区大小，单位是字节，最小 0，最大 512，通常可以设置为 128。
+  * B：中间计算结果的缓冲区大小，单位是字节，最小 0，最大 512，如果不使用可以不设置。
+
+  关于中间计算结果的使用，可以参考示例程序[demo.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/demo.c)
   
-  例如，如下语句可以把 abs_max.so 创建为系统中可用的 UDF：
+  例如，如下语句可以把 demo.so 创建为系统中可用的 UDF：
   ```sql
-  CREATE AGGREGATE FUNCTION abs_max AS "/home/taos/udf_example/abs_max.so" OUTPUTTYPE BIGINT bufsize 128;
+  CREATE AGGREGATE FUNCTION demo AS "/home/taos/udf_example/demo.so" OUTPUTTYPE DOUBLE bufsize 14;
   ```
 
 ### 管理 UDF
@@ -140,7 +136,7 @@ SELECT X(c) FROM table/stable;
 
 在当前版本下，使用 UDF 存在如下这些限制：
 1. 在创建和调用 UDF 时，服务端和客户端都只支持 Linux 操作系统；
-2. UDF 不能与系统内建的 SQL 函数混合使用；
+2. UDF 不能与系统内建的 SQL 函数混合使用，暂不支持在一条 SQL 语句中使用多个不同名的 UDF ；
 3. UDF 只支持以单个数据列作为输入；
 4. UDF 只要创建成功，就会被持久化存储到 MNode 节点中；
 5. 无法通过 RESTful 接口来创建 UDF；

documentation20/cn/12.taos-sql/docs.md

@@ -171,6 +171,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
     4) 子表名只能由字母、数字和下划线组成，且不能以数字开头，不区分大小写
 
     5) 使用数据类型 binary 或 nchar，需指定其最长的字节数，如 binary(20)，表示 20 字节；
+    
     6) 为了兼容支持更多形式的表名，TDengine 引入新的转义符 "\`"，可以让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。但是同样具有长度限制要求。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
     例如：\`aBc\` 和 \`abc\` 是不同的表名，但是 abc 和 aBc 是相同的表名。
     需要注意的是转义字符中的内容必须是可打印字符。
@@ -728,17 +729,17 @@ Query OK, 1 row(s) in set (0.001091s)
 
 | **Operation** | **Note**                 | **Applicable Data Types**                 |
 | ------------- | ------------------------ | ----------------------------------------- |
-| >             | larger than              | **`timestamp`** and all numeric types     |
-| <             | smaller than             | **`timestamp`** and all numeric types     |
-| >=            | larger than or equal to  | **`timestamp`** and all numeric types     |
-| <=            | smaller than or equal to | **`timestamp`** and all numeric types     |
+| >             | larger than              | all types except bool                     |
+| <             | smaller than             | all types except bool                     |
+| >=            | larger than or equal to  | all types except bool                     |
+| <=            | smaller than or equal to | all types except bool                     |
 | =             | equal to                 | all types                                 |
 | <>            | not equal to             | all types                                 |
 | is [not] null | is null or is not null   | all types                                 |
-| between and   | within a certain range   | **`timestamp`** and all numeric types     |
+| between and   | within a certain range   | all types except bool                     |
 | in            | match any value in a set | all types except first column `timestamp` |
 | like          | match a wildcard string  | **`binary`** **`nchar`**                  |
-| match/nmatch  | filter regex             | **regex**                                 |
+| match/nmatch  | filter regex             | **`binary`** **`nchar`**                  |
 
 1. <> 算子也可以写为 != ，请注意，这个算子不能用于数据表第一列的 timestamp 字段。
 2. like 算子使用通配符字符串进行匹配检查。
@@ -765,15 +766,10 @@ Query OK, 1 row(s) in set (0.001091s)
 
    **使用限制**
 
-   只能针对表名（即 tbname 筛选）和标签的名称和binary类型标签值 进行正则表达式过滤，不支持针对普通列使用正则表达式过滤。
-
-   只能在 WHERE 子句中作为过滤条件存在。
+   只能针对表名（即 tbname 筛选）、binary/nchar类型标签值进行正则表达式过滤，不支持普通列的过滤。
 
    正则匹配字符串长度不能超过 128 字节。可以通过参数 *maxRegexStringLen* 设置和调整最大允许的正则匹配字符串，该参数是客户端配置参数，需要重启才能生效。
 
-   **嵌套查询支持**
-
-   可以在内层查询和外层查询中使用。<!-- REPLACE_OPEN_TO_ENTERPRISE__IN_OPERATOR_AND_UNSIGNED_INTEGER -->
 
 <a class="anchor" id="join"></a>
 ### JOIN 子句
@@ -1578,11 +1574,11 @@ SELECT function_list FROM stb_name
 CREATE TABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT);
 ```
 
-针对智能电表采集的数据，以 10 分钟为一个阶段，计算过去 24 小时的电流数据的平均值、最大值、电流的中位数、以及随着时间变化的电流走势拟合直线。如果没有计算值，用前一个非 NULL 值填充。使用的查询语句如下：
+针对智能电表采集的数据，以 10 分钟为一个阶段，计算过去 24 小时的电流数据的平均值、最大值、电流的中位数。如果没有计算值，用前一个非 NULL 值填充。使用的查询语句如下：
 
 ```mysql
-SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), PERCENTILE(current, 50) FROM meters
-  WHERE ts>=NOW-1d
+SELECT AVG(current), MAX(current), APERCENTILE(current, 50) FROM meters
+  WHERE ts>=NOW-1d and ts<=now
   INTERVAL(10m)
   FILL(PREV);
 ```

documentation20/en/00.index/docs.md

@@ -77,6 +77,7 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 - [Node.js Connector](/connector#nodejs): driver for connecting to TDengine server from Node.js applications
 - [C# Connector](/connector#csharp): driver for connecting to TDengine server from C# applications
 - [Windows Client](https://www.taosdata.com/blog/2019/07/26/514.html): compile your own Windows client, which is required by various connectors on the Windows environment
+- [Rust Connector](/connector/rust): A taosc/RESTful API based TDengine client for Rust
 
 ## [Connections with Other Tools](/connections)
 

grafanaplugin @ 9ae793ad

-Subproject commit edad746514b2a53a8cf6061c93b98b52a5388692
+Subproject commit 9ae793ad2d567eb11d10627b65698f612542e988