Merge branch 'develop' of github.com:taosdata/TDengine into dev/chr

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
@@ -181,9 +179,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 +192,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,7 +200,8 @@ pipeline {
   stages {
       stage('pre_build'){
           agent{label 'master'}
-          when {
+          options { skipDefaultCheckout() } 
+          when{
                 changeRequest()
           }
           steps {
@@ -209,59 +209,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 '''
@@ -414,7 +413,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
@@ -471,35 +470,35 @@ pipeline {
           }
         } 
         
-        // 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

@@ -124,17 +124,25 @@ IF (TD_APLHINE)
   MESSAGE(STATUS "aplhine is defined")
 ENDIF ()
 
-IF (TD_LINUX)
+MESSAGE("before BUILD_HTTP: " ${BUILD_HTTP})
+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 ()
+MESSAGE("after BUILD_HTTP: " ${BUILD_HTTP})
+
+IF (${BUILD_HTTP} MATCHES "true")
   SET(TD_BUILD_HTTP TRUE)
+ENDIF ()
+
+IF (TD_BUILD_HTTP)
   ADD_DEFINITIONS(-DHTTP_EMBEDDED)
 ENDIF ()
 

cmake/input.inc

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

documentation20/cn/00.index/docs.md

@@ -131,7 +131,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/05.insert/docs.md

@@ -243,7 +243,7 @@ repeater 部分添加 { host:'<TDengine server/cluster host>', port: <port for S
 {
 port: 8125
 , backends: ["./backends/repeater"]
-, repeater: [{ host: '127.0.0.1', port: 8126}]
+, repeater: [{ host: '127.0.0.1', port: 6044}]
 }
 ```
 

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/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 是相同的表名。
     需要注意的是转义字符中的内容必须是可打印字符。
@@ -1578,11 +1579,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/cn/13.faq/docs.md

@@ -184,8 +184,9 @@ TDengine 中时间戳的时区总是由客户端进行处理，而与服务端
 | TCP | 6040      | 多节点集群的节点间数据同步。        | 随 serverPort 端口变化。         |
 | TCP | 6041      | 客户端与服务端之间的 RESTful 通讯。 | 随 serverPort 端口变化。        |
 | TCP | 6042      | Arbitrator 的服务端口。           | 随 Arbitrator 启动参数设置变化。 |
-| TCP | 6043      | 支持 collectd 数据接入端口。        | 随 BLM3 启动参数设置变化（2.3.0.1+以上版本）。 |
+| TCP | 6043      | TaosKeeper 监控服务端口。         | 随 TaosKeeper 启动参数设置变化。 |
 | TCP | 6044      | 支持 StatsD 的数据接入端口。       | 随 BLM3 启动参数设置变化（2.3.0.1+以上版本）。 |
+| TCP | 6045      | 支持 collectd 数据接入端口。       | 随 BLM3 启动参数设置变化（2.3.0.1+以上版本）。 |
 | TCP | 6060      | 企业版内 Monitor 服务的网络端口。   |                               |
 | UDP | 6030-6034 | 客户端与服务端之间通讯。            | 随 serverPort 端口变化。        |
 | UDP | 6035-6039 | 多节点集群的节点间通讯。            | 随 serverPort 端口变化。        |
@@ -193,12 +194,14 @@ TDengine 中时间戳的时区总是由客户端进行处理，而与服务端
 ## 20. go 语言编写组件编译失败怎样解决？
 
 新版本 TDengine 2.3.0.0 包含一个使用 go 语言开发的 BLM3 组件，取代之前内置的 httpd ，提供包含原  httpd 功能以及支持多种其他软件（Prometheus、Telegraf、collectd、StatsD等）的数据接入功能。
-使用最新 develop 分支代码编译需要先 git submodule update --init --recursive 下载 blm3 仓库代码后再编译。
+使用最新 develop 分支代码编译需要先 `git submodule update --init --recursive` 下载 blm3 仓库代码后再编译。
 
 目前编译方式默认自动编译 blm3。go 语言版本要求 1.14 以上，如果发生 go 编译错误，往往是国内访问 go mod 问题，可以通过设置 go 环境变量来解决：
+
+```sh
 go env -w GO111MODULE=on
 go env -w GOPROXY=https://goproxy.cn,direct
+```
 
 如果希望继续使用之前的内置 httpd，可以关闭 blm3 编译，使用 
-cmake .. -DBUILD_HTTP=true 使用原来内置的 httpd。
-
+`cmake .. -DBUILD_HTTP=true` 使用原来内置的 httpd。

documentation20/cn/14.devops/02.collectd/docs.md

@@ -57,7 +57,7 @@ repeater 部分添加 { host:'<TDengine server/cluster host>', port: <port for S
 
 ### 导入 Dashboard
 
-使用 Web 浏览器访问 IP:3000 登录 Grafana 界面，系统初始用户名密码为 admin/admin。
+使用 Web 浏览器访问运行 Grafana 的服务器的3000端口 host:3000 登录 Grafana 界面，系统初始用户名密码为 admin/admin。
 点击左侧齿轮图标并选择 Plugins，应该可以找到 TDengine data source 插件图标。
 
 #### 导入 collectd 仪表盘

documentation20/en/08.connector/docs.md

@@ -419,19 +419,47 @@ or
 
  `pip3 install src/connector/python/`
 
+You can install the `taospy` connector from [PyPI](https://pypi.org/project/taospy/):
+
+```sh
+pip install taospy
+```
+
 #### Windows
 
-With Windows TDengine client installed, copy the file "C:\TDengine\driver\taos.dll" to the "C:\ windows\ system32" directory and enter the Windows <em>cmd</em> command line interface:
+With Windows TDengine client installed, copy the file "C:\TDengine\driver\taos.dll" to the "C:\Windows\system32" directory and enter the Windows *cmd* command line interface:
 
 ```cmd
 cd C:\TDengine\connector\python
 python -m pip install .
 ```
 
+Or install from PyPI:
+
+```cmd
+pip install taospy
+```
+
 - If there is no `pip` command on the machine, the user can copy the taos folder under src/connector/python to the application directory for use. For Windows client, after installing the TDengine Windows client, copy C:\ TDengine\driver\taos.dll to the C:\ windows\ system32 directory.
 
 ### How to use
 
+#### PEP-249 Python Database API
+
+Definitely you can use the [PEP-249](https://www.python.org/dev/peps/pep-0249/) database API like other type of databases:
+
+```python
+import taos
+
+conn = taos.connect()
+cursor = conn.cursor()
+
+cursor.execute("show databases")
+results = cursor.fetchall()
+for row in results:
+    print(row)
+```
+
 #### Code sample
 
 - Import the TDengine client module
@@ -488,6 +516,44 @@ for data in c1:
   print("ts=%s, temperature=%d, humidity=%f" %(data[0], data[1],data[2]))
 ```
 
+- Since v2.1.0, python connector provides a new API for 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")
+```
+
+The `query` method returns `TaosResult` class. It provides high level APIs for convenient use:
+
+Properties:
+
+- `fields`: the `TaosFields` object contains the column metadata, given the collection of each column field metadata by iterator.
+- `field_count`: column number of result.
+- `affected_rows`: the rows completed for insert.
+- `row_count`: the rows number for select.
+- `precision`: the result precision.
+
+Functions:
+
+- `fetch_all()`: get all data as tuple array.
+- `fetch_all_into_dict()`: get all data as dict array, added since v2.1.1
+- `blocks_iter()`: provides iterator by C `taos_fetch_blocks` API
+- `rows_iter()`: provides iterator by C `taos_fetch_row` API
+- `fetch_rows_a`: fetch rows by async API in taosc.
+- `errno`: error code if failed.
+- `errstr`: error string if failed.
+- `close`: close result, you do not need to call it directly, result will auto closed out of scope.
+
 - Create subscription
 
 ```python
@@ -510,6 +576,7 @@ for d in data:
 sub.close()
 ```
 
+
 - Close connection
 
 ```python

packaging/cfg/taos.cfg

@@ -301,3 +301,6 @@ keepColumnName            1
 
 # force TCP transmission 
 # rpcForceTcp        0
+
+# unit MB. Flush vnode wal file if walSize > walFlushSize and walSize > cache*0.5*blocks
+# walFlushSize         1024

packaging/docker/Dockerfile

@@ -4,20 +4,18 @@ WORKDIR /root
 
 ARG pkgFile
 ARG dirName
-RUN echo ${pkgFile}
-RUN echo ${dirName}
+RUN echo ${pkgFile} && echo ${dirName}
 
 COPY ${pkgFile} /root/
 RUN tar -zxf ${pkgFile}
 WORKDIR /root/${dirName}/
 RUN /bin/bash install.sh -e no
 
-RUN apt-get clean && apt-get update && apt-get install -y locales
-RUN locale-gen en_US.UTF-8
-ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib"
-ENV LC_CTYPE=en_US.UTF-8
-ENV LANG=en_US.UTF-8
-ENV LC_ALL=en_US.UTF-8
+RUN apt-get clean && apt-get update && apt-get install -y locales && locale-gen en_US.UTF-8
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib" \
+    LC_CTYPE=en_US.UTF-8 \
+    LANG=en_US.UTF-8 \
+    LC_ALL=en_US.UTF-8
 
 EXPOSE 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042
 CMD ["taosd"]

packaging/release.sh

@@ -213,7 +213,7 @@ else
   exit 1
 fi
 
-make -j8
+make
 
 cd ${curr_dir}
 

packaging/tools/make_install.sh

@@ -395,8 +395,9 @@ function install_connector() {
         ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector
         ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar  || echo &> /dev/null
     else
-        ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector || ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_2_dir}/connector}
-        ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null || cp ${binary_dir}/build/lib/*.jar ${install_main_2_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar || ${csudo} chmod 777 ${install_main_2_dir}/connector/*.jar || echo &> /dev/null
+        ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector || ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_2_dir}/connector
+        ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar  || echo &> /dev/null
+        ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_2_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_2_dir}/connector/*.jar  || echo &> /dev/null
     fi
 }
 

snap/snapcraft.yaml

 name: tdengine
-base: core18
+base: core20
 version: '2.3.0.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
@@ -39,14 +39,17 @@ parts:
       - taoswrapper.sh
 
   tdengine:
+    plugin: cmake
     source: .
     source-type: local
-    plugin: cmake
     build-packages:
       - gcc
       - g++
       - make
       - cmake
+    cmake-parameters:
+      - -DCMAKE_BUILD_TYPE=Release
+      - -DBUILD_HTTP=true
     override-build: |
       snapcraftctl build
       if [ ! -d $SNAPCRAFT_STAGE/usr ]; then

src/client/inc/tscParseLine.h

@@ -23,6 +23,8 @@ extern "C" {
 #define SML_TIMESTAMP_SECOND_DIGITS 10
 #define SML_TIMESTAMP_MILLI_SECOND_DIGITS 13
 
+typedef TSDB_SML_PROTOCOL_TYPE SMLProtocolType;
+
 typedef struct {
   char* key;
   uint8_t type;
@@ -46,31 +48,26 @@ typedef struct {
 } TAOS_SML_DATA_POINT;
 
 typedef enum {
-  SML_TIME_STAMP_NOW,
+  SML_TIME_STAMP_NOT_CONFIGURED,
   SML_TIME_STAMP_HOURS,
   SML_TIME_STAMP_MINUTES,
   SML_TIME_STAMP_SECONDS,
   SML_TIME_STAMP_MILLI_SECONDS,
   SML_TIME_STAMP_MICRO_SECONDS,
   SML_TIME_STAMP_NANO_SECONDS,
-  SML_TIME_STAMP_NOT_CONFIGURED
+  SML_TIME_STAMP_NOW
 } SMLTimeStampType;
 
-typedef enum {
-  SML_LINE_PROTOCOL = 0,
-  SML_TELNET_PROTOCOL = 1,
-  SML_JSON_PROTOCOL = 2,
-} SMLProtocolType;
-
 typedef struct {
   uint64_t id;
   SMLProtocolType protocol;
   SMLTimeStampType tsType;
   SHashObj* smlDataToSchema;
 
-  int64_t affectedRows;
+  int32_t affectedRows;
 } SSmlLinesInfo;
 
+void addEscapeCharToString(char *str, int32_t len);
 int tscSmlInsert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint, SSmlLinesInfo* info);
 bool checkDuplicateKey(char *key, SHashObj *pHash, SSmlLinesInfo* info);
 bool isValidInteger(char *str);
@@ -85,12 +82,12 @@ int32_t convertSmlTimeStamp(TAOS_SML_KV *pVal, char *value,
 
 void destroySmlDataPoint(TAOS_SML_DATA_POINT* point);
 
-int taos_insert_sml_lines(TAOS* taos, char* lines[], int numLines,
-                          SMLProtocolType protocol, SMLTimeStampType tsType);
-int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines,
-                             SMLProtocolType protocol, SMLTimeStampType tsType);
-int taos_insert_json_payload(TAOS* taos, char* payload,
-                             SMLProtocolType protocol, SMLTimeStampType tsType);
+int taos_insert_lines(TAOS* taos, char* lines[], int numLines, SMLProtocolType protocol,
+                      SMLTimeStampType tsType, int* affectedRows);
+int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines, SMLProtocolType protocol,
+                             SMLTimeStampType tsType, int* affectedRows);
+int taos_insert_json_payload(TAOS* taos, char* payload, SMLProtocolType protocol,
+                             SMLTimeStampType tsType, int* affectedRows);
 
 
 #ifdef __cplusplus

src/client/inc/tscUtil.h

@@ -251,6 +251,7 @@ void tscColumnListCopyAll(SArray* dst, const SArray* src);
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo, uint64_t objId, bool convertNchar);
 
 void tscDequoteAndTrimToken(SStrToken* pToken);
+void tscRmEscapeAndTrimToken(SStrToken* pToken);
 int32_t tscValidateName(SStrToken* pToken, bool escapeEnabled, bool *dbIncluded);
 
 void tscIncStreamExecutionCount(void* pStream);

src/client/jni/com_alibaba_datax_plugin_writer_JniConnection.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_alibaba_datax_plugin_writer_JniConnection */
+
+#ifndef _Included_com_alibaba_datax_plugin_writer_JniConnection
+#define _Included_com_alibaba_datax_plugin_writer_JniConnection
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_alibaba_datax_plugin_writer_JniConnection_JNI_NULL_POINTER
+#define com_alibaba_datax_plugin_writer_JniConnection_JNI_NULL_POINTER 0LL
+#undef com_alibaba_datax_plugin_writer_JniConnection_JNI_SUCCESSFUL
+#define com_alibaba_datax_plugin_writer_JniConnection_JNI_SUCCESSFUL 0L
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    initImp
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_initImp
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    setOptions
+ * Signature: (ILjava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_setOptions
+  (JNIEnv *, jclass, jint, jstring);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    connectImp
+ * Signature: (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_connectImp
+  (JNIEnv *, jobject, jstring, jint, jstring, jstring, jstring);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    getErrCodeImp
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_getErrCodeImp
+  (JNIEnv *, jobject, jlong, jlong);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    getErrMsgImp
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_getErrMsgImp
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    freeResultSetImp
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_freeResultSetImp
+  (JNIEnv *, jobject, jlong, jlong);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    closeConnectionImp
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_closeConnectionImp
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_alibaba_datax_plugin_writer_JniConnection
+ * Method:    insertOpentsdbJson
+ * Signature: (Ljava/lang/String;J)J
+ */
+JNIEXPORT jlong JNICALL Java_com_alibaba_datax_plugin_writer_JniConnection_insertOpentsdbJson
+  (JNIEnv *, jobject, jstring, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/client/jni/jniCommon.h

+#include <jni.h>
+
+#ifndef TDENGINE_JNICOMMON_H
+#define TDENGINE_JNICOMMON_H
+
+#define jniFatal(...)                                                            \
+  {                                                                              \
+    if (jniDebugFlag & DEBUG_FATAL) {                                            \
+      taosPrintLog("JNI FATAL ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+    }                                                                            \
+  }
+#define jniError(...)                                                            \
+  {                                                                              \
+    if (jniDebugFlag & DEBUG_ERROR) {                                            \
+      taosPrintLog("JNI ERROR ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+    }                                                                            \
+  }
+#define jniWarn(...)                                                            \
+  {                                                                             \
+    if (jniDebugFlag & DEBUG_WARN) {                                            \
+      taosPrintLog("JNI WARN ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+    }                                                                           \
+  }
+#define jniInfo(...)                                                       \
+  {                                                                        \
+    if (jniDebugFlag & DEBUG_INFO) {                                       \
+      taosPrintLog("JNI ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+    }                                                                      \
+  }
+#define jniDebug(...)                                  \
+  {                                                    \
+    if (jniDebugFlag & DEBUG_DEBUG) {                  \
+      taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
+    }                                                  \
+  }
+#define jniTrace(...)                                  \
+  {                                                    \
+    if (jniDebugFlag & DEBUG_TRACE) {                  \
+      taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
+    }                                                  \
+  }
+
+extern jclass    g_arrayListClass;
+extern jmethodID g_arrayListConstructFp;
+extern jmethodID g_arrayListAddFp;
+
+extern jclass    g_metadataClass;
+extern jmethodID g_metadataConstructFp;
+extern jfieldID  g_metadataColtypeField;
+extern jfieldID  g_metadataColnameField;
+extern jfieldID  g_metadataColsizeField;
+extern jfieldID  g_metadataColindexField;
+
+extern jclass    g_rowdataClass;
+extern jmethodID g_rowdataConstructor;
+extern jmethodID g_rowdataClearFp;
+extern jmethodID g_rowdataSetBooleanFp;
+extern jmethodID g_rowdataSetByteFp;
+extern jmethodID g_rowdataSetShortFp;
+extern jmethodID g_rowdataSetIntFp;
+extern jmethodID g_rowdataSetLongFp;
+extern jmethodID g_rowdataSetFloatFp;
+extern jmethodID g_rowdataSetDoubleFp;
+extern jmethodID g_rowdataSetStringFp;
+extern jmethodID g_rowdataSetTimestampFp;
+extern jmethodID g_rowdataSetByteArrayFp;
+
+extern jmethodID g_blockdataSetByteArrayFp;
+extern jmethodID g_blockdataSetNumOfRowsFp;
+extern jmethodID g_blockdataSetNumOfColsFp;
+
+#define JNI_SUCCESS 0
+#define JNI_TDENGINE_ERROR -1
+#define JNI_CONNECTION_NULL -2
+#define JNI_RESULT_SET_NULL -3
+#define JNI_NUM_OF_FIELDS_0 -4
+#define JNI_SQL_NULL -5
+#define JNI_FETCH_END -6
+#define JNI_OUT_OF_MEMORY -7
+
+extern JavaVM *g_vm;
+
+void jniGetGlobalMethod(JNIEnv *env);
+
+int32_t check_for_params(jobject jobj, jlong conn, jlong res);
+
+#endif  // TDENGINE_JNICOMMON_H

src/client/src/taos.def

@@ -51,3 +51,4 @@ taos_stmt_bind_param_batch
 taos_stmt_bind_single_param_batch
 taos_is_null
 taos_insert_lines
+taos_schemaless_insert

src/client/src/tscParseInsert.c

@@ -1251,10 +1251,18 @@ static int32_t parseBoundColumns(SInsertStatementParam *pInsertParam, SParsedDat
     sToken = tStrGetToken(str, &index, false);
     str += index;
 
+    char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0}; // used for deleting Escape character backstick(`)
+    strncpy(tmpTokenBuf, sToken.z, sToken.n);
+    sToken.z = tmpTokenBuf;
+
     if (TK_STRING == sToken.type) {
       tscDequoteAndTrimToken(&sToken);
     }
 
+    if (TK_ID == sToken.type) {
+      tscRmEscapeAndTrimToken(&sToken);
+    }
+
     if (sToken.type == TK_RP) {
       if (end != NULL) {  // set the end position
         *end = str;

src/client/src/tscServer.c

@@ -1102,6 +1102,11 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   // support only one udf
   if (pQueryInfo->pUdfInfo != NULL && taosArrayGetSize(pQueryInfo->pUdfInfo) > 0) {
+    if (taosArrayGetSize(pQueryInfo->pUdfInfo) > 1) {
+      code = tscInvalidOperationMsg(pCmd->payload, "only one udf allowed", NULL);
+      goto _end;
+    }
+    
     pQueryMsg->udfContentOffset = htonl((int32_t) (pMsg - pCmd->payload));
     for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
       SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, i);

src/client/src/tscSql.c

@@ -629,6 +629,10 @@ static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
     return false;
   }
 
+  if (pCmd->payload == NULL) {
+    return false;
+  }
+
   size_t len = strlen(pCmd->payload);
 
   char *z = NULL;

src/common/inc/tglobal.h

@@ -111,6 +111,7 @@ extern int8_t  tsCacheLastRow;
 //tsdb
 extern bool    tsdbForceKeepFile;
 extern bool    tsdbForceCompactFile;
+extern int32_t tsdbWalFlushSize;
 
 // balance
 extern int8_t  tsEnableBalance;

src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java

@@ -9,6 +9,7 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
 
     protected List<String> batchedArgs;
     private int fetchSize;
+    protected int affectedRows = -1;
 
     @Override
     public abstract ResultSet executeQuery(String sql) throws SQLException;
@@ -247,6 +248,7 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
     public boolean getMoreResults(int current) throws SQLException {
         if (isClosed())
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+        this.affectedRows = -1;
         switch (current) {
             case Statement.CLOSE_CURRENT_RESULT:
                 return false;

blm3 @ f56aa0f4

-Subproject commit 4bfae86dcabea0d5a40ff81a72be7c822737269b
+Subproject commit f56aa0f485d7bb6aebbcefc2007eeecdccb767c8