Merge branch 'develop' into feature/TD-1413

de1a75f6 · Hongze Cheng · bc2f0d9d · df74e517 · de1a75f6 · de1a75f6
361 changed file
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,9 @@
 [submodule "src/connector/grafanaplugin"]
 	path = src/connector/grafanaplugin
 	url = https://github.com/taosdata/grafanaplugin
+[submodule "tests/examples/rust"]
+	path = tests/examples/rust
+	url = https://github.com/songtianyi/tdengine-rust-bindings.git
+[submodule "src/connector/hivemq-tdengine-extension"]
+	path = src/connector/hivemq-tdengine-extension
+	url = https://github.com/huskar-t/hivemq-tdengine-extension.git
\ No newline at end of file
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -27,6 +27,7 @@ pipeline {
            cd debug
            cmake .. > /dev/null
            make > /dev/null
+            make install > /dev/null
            cd ${WKC}/tests
            #./test-all.sh smoke
            ./test-all.sh pytest
@@ -79,7 +80,20 @@ pipeline {
            cmake .. > /dev/null
            make > /dev/null
            cd ${WKC}/tests/pytest
-            ./crash_gen.sh -a -p -t 4 -s 2000
+            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                ./crash_gen.sh -a -p -t 4 -s 2000
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                ./handle_crash_gen_val_log.sh
+                '''
+            }
+            sh '''
            date
            cd ${WKC}/tests
            ./test-all.sh b2
@@ -124,14 +138,33 @@ pipeline {
            sh'''
            cd ${WORKSPACE}
            git checkout develop
-            cd tests/gotest
-            bash batchtest.sh
-            cd ${WORKSPACE}/tests/examples/JDBC/JDBCDemo/
-            mvn clean package assembly:single >/dev/null 
-            java -jar target/jdbcChecker-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
-            cd ${WORKSPACE}/tests/examples/python/PYTHONConnectorChecker
-            python3 PythonChecker.py
            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WORKSPACE}/tests/gotest
+                bash batchtest.sh
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WORKSPACE}/tests/examples/python/PYTHONConnectorChecker
+                python3 PythonChecker.py
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WORKSPACE}/tests/examples/JDBC/JDBCDemo/
+                mvn clean package assembly:single >/dev/null 
+                java -jar target/jdbcChecker-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${JENKINS_HOME}/workspace/C#NET/src/CheckC#
+                dotnet run
+                '''
+            }
+          
         }
       }

@@ -139,5 +172,82 @@ pipeline {
    }

  }
-  
+  post {             
+        success {
+            emailext (
+                subject: "SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>变更概要：${CHANGES}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "yqliu@taosdata.com,pxiao@taosdata.com",
+                from: "support@taosdata.com"
+            )
+        }
+        failure {
+            emailext (
+                subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>变更概要：${CHANGES}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "yqliu@taosdata.com,pxiao@taosdata.com",
+                from: "support@taosdata.com"
+            )
+        }
+    }
 }
\ No newline at end of file
--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -13,6 +13,7 @@ ELSEIF (TD_WINDOWS)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go     DESTINATION connector)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/nodejs DESTINATION connector)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/C\# DESTINATION connector)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/tests/examples DESTINATION .)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/packaging/cfg DESTINATION .)
  INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taos.h DESTINATION include)

--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.6.0")
+  SET(TD_VER_NUMBER "2.0.7.0")
 ENDIF ()

 IF (DEFINED VERCOMPATIBLE)

--- a/documentation/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation/webdocs/markdowndocs/administrator-ch.md
@@ -87,6 +87,7 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 - httpPort: RESTful服务使用的端口号，所有的HTTP请求（TCP）都需要向该接口发起查询/写入请求。
 - dataDir: 数据文件目录，所有的数据文件都将写入该目录。默认值：/var/lib/taos。
 - logDir：日志文件目录，客户端和服务器的运行日志文件将写入该目录。默认值：/var/log/taos。
+- tempDir：临时文件目录，客户端和服务器的临时文件（主要是查询时用于保存中间结果的问题）将写入该目录。 默认值：Linux下为 /tmp/，Windows下为环境变量 tmp 或 temp 指向的目录。
 - arbitrator：系统中裁决器的end point, 缺省值为空。
 - role：dnode的可选角色。0-any; 既可作为mnode，也可分配vnode；1-mgmt;只能作为mnode，不能分配vnode；2-dnode;不能作为mnode，只能分配vnode
 - debugFlag：运行日志开关。131（输出错误和警告日志），135（ 输出错误、警告和调试日志），143（ 输出错误、警告、调试和跟踪日志）。默认值：131或135（不同模块有不同的默认值）。

--- a/documentation20/webdocs/markdowndocs/Documentation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Documentation-ch.md
@@ -34,7 +34,8 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 - [SQL写入](https://www.taosdata.com/cn/documentation20/insert/#SQL写入)：使用SQL insert命令向一张或多张表写入单条或多条记录
 - [Telegraf写入](https://www.taosdata.com/cn/documentation20/insert/#Telegraf直接写入)：配置Telegraf, 不用任何代码，将采集数据直接写入
 - [Prometheus写入](https://www.taosdata.com/cn/documentation20/insert/#Prometheus直接写入)：配置Prometheus, 不用任何代码，将数据直接写入
- [EMQ X Broker](https://www.taosdata.com/cn/documentation20/insert/#EMQ-X-Broker直接写入)：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
+- [EMQ X Broker](https://www.taosdata.com/cn/documentation20/insert/#EMQ-X-Broker直接写入)：配置EMQ X，不用任何代码，就可将 MQTT 数据直接写入
+- [HiveMQ Broker](https://www.taosdata.com/cn/documentation20/insert/#HiveMQ-Broker直接写入)：通过 HiveMQ Extension，不用任何代码，就可将 MQTT 数据直接写入

 ## [高效查询数据](https://www.taosdata.com/cn/documentation20/queries)


--- a/documentation20/webdocs/markdowndocs/Evaluation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Evaluation-ch.md
@@ -10,7 +10,7 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 * __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
 * __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
 * __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, Matlab随时进行。
-* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
+* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
 * __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类似标准SQL，支持RESTful, 支持Python/Java/C/C++/C#/Go/Node.js, 与MySQL相似，零学习成本。

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

--- a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
+++ b/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
@@ -90,7 +90,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    ```mysql
    ALTER DATABASE db_name REPLICA 2;
    ```
-    REPLICA参数是指修改数据库副本数，取值范围[1, 3]。在集群中使用，副本数必须小于dnode的数目。
+    REPLICA参数是指修改数据库副本数，取值范围[1, 3]。在集群中使用，副本数必须小于或等于dnode的数目。

    ```mysql
    ALTER DATABASE db_name KEEP 365;
@@ -844,7 +844,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数

 - **PERCENTILE**
    ```mysql
-    SELECT PERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
+    SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
    ```
    功能说明：统计表中某列的值百分比分位数。  
    返回结果数据类型： 双精度浮点数Double。  
@@ -1016,9 +1016,9 @@ SELECT AVG(current),MAX(current),LEASTSQUARES(current, start_val, step_val), PER
 ```

 ## TAOS SQL 边界限制
- 数据库名最大长度为33
- 表名最大长度为193，每行数据最大长度16k个字符
- 列名最大长度为65，最多允许1024列，最少需要2列，第一列必须是时间戳
+- 数据库名最大长度为32
+- 表名最大长度为192，每行数据最大长度16k个字符
+- 列名最大长度为64，最多允许1024列，最少需要2列，第一列必须是时间戳
 - 标签最多允许128个，可以0个，标签总长度不超过16k个字符
 - SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/webdocs/markdowndocs/administrator-ch.md
@@ -35,7 +35,7 @@ TDengine相对于通用数据库，有超高的压缩比，在绝大多数场景
 Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
 ```

-示例：1000万台智能电表，每台电表每15分钟采集一次数据，每次采集的数据128字节，那么一年的原始数据量是：10000000\*128\*24\*60/15*365 = 44851T。TDengine大概需要消耗44851/5=8970T, 8.9P空间。 
+示例：1000万台智能电表，每台电表每15分钟采集一次数据，每次采集的数据128字节，那么一年的原始数据量是：10000000\*128\*24\*60/15*365 = 44.8512T。TDengine大概需要消耗44.851/5=8.97024T空间。 

 用户可以通过参数keep，设置数据在磁盘中的最大保存时长。为进一步减少存储成本，TDengine还提供多级存储，最冷的数据可以存放在最廉价的存储介质上，应用的访问不用做任何调整，只是读取速度降低了。

@@ -253,7 +253,7 @@ ALTER USER <user_name> PASS <'password'>;
 修改用户密码, 为避免被转换为小写，密码需要用单引号引用,单引号为英文半角

 ```
-ALTER USER <user_name> PRIVILEDGE <super|write|read>;
+ALTER USER <user_name> PRIVILEGE <super|write|read>;
 ```

 修改用户权限为：super/write/read，不需要添加单引号

--- a/documentation20/webdocs/markdowndocs/architecture-ch.md
+++ b/documentation20/webdocs/markdowndocs/architecture-ch.md
@@ -4,16 +4,99 @@
 ### 物联网典型场景
 在典型的物联网、车联网、运维监测场景中，往往有多种不同类型的数据采集设备，采集一个到多个不同的物理量。而同一种采集设备类型，往往又有多个具体的采集设备分布在不同的地点。大数据处理系统就是要将各种采集的数据汇总，然后进行计算和分析。对于同一类设备，其采集的数据都是很规则的。以智能电表为例，假设每个智能电表采集电流、电压、相位三个量，其采集的数据类似如下的表格：

-| Device ID |  Time Stamp   | current | voltage | phase |     location     | groupId |
-| :-------: | :-----------: | :-----: | :-----: | :---: | :--------------: | :-----: |
-|   d1001   | 1538548685000 |  10.3   |   219   | 0.31  | Beijing.Chaoyang |    2    |
-|   d1002   | 1538548684000 |  10.2   |   220   | 0.23  | Beijing.Chaoyang |    3    |
-|   d1003   | 1538548686500 |  11.5   |   221   | 0.35  | Beijing.Haidian  |    3    |
-|   d1004   | 1538548685500 |  13.4   |   223   | 0.29  | Beijing.Haidian  |    2    |
-|   d1001   | 1538548695000 |  12.6   |   218   | 0.33  | Beijing.Chaoyang |    2    |
-|   d1004   | 1538548696600 |  11.8   |   221   | 0.28  | Beijing.Haidian  |    2    |
-|   d1002   | 1538548696650 |  10.3   |   218   | 0.25  | Beijing.Chaoyang |    3    |
-|   d1001   | 1538548696800 |  12.3   |   221   | 0.31  | Beijing.Chaoyang |    2    |
+<figure><table>
+<thead><tr>
+    <th style="text-align:center;">设备ID</th>
+    <th style="text-align:center;">时间戳</th>
+    <th style="text-align:center;" colspan="3">采集量</th>
+    <th style="text-align:center;" colspan="2">标签</th>
+    </tr>
+
+<tr>
+<th style="text-align:center;">Device ID</th>
+<th style="text-align:center;">Time Stamp</th>
+<th style="text-align:center;">current</th>
+<th style="text-align:center;">voltage</th>
+<th style="text-align:center;">phase</th>
+<th style="text-align:center;">location</th>
+<th style="text-align:center;">groupId</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td style="text-align:center;">d1001</td>
+<td style="text-align:center;">1538548685000</td>
+<td style="text-align:center;">10.3</td>
+<td style="text-align:center;">219</td>
+<td style="text-align:center;">0.31</td>
+<td style="text-align:center;">Beijing.Chaoyang</td>
+<td style="text-align:center;">2</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1002</td>
+<td style="text-align:center;">1538548684000</td>
+<td style="text-align:center;">10.2</td>
+<td style="text-align:center;">220</td>
+<td style="text-align:center;">0.23</td>
+<td style="text-align:center;">Beijing.Chaoyang</td>
+<td style="text-align:center;">3</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1003</td>
+<td style="text-align:center;">1538548686500</td>
+<td style="text-align:center;">11.5</td>
+<td style="text-align:center;">221</td>
+<td style="text-align:center;">0.35</td>
+<td style="text-align:center;">Beijing.Haidian</td>
+<td style="text-align:center;">3</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1004</td>
+<td style="text-align:center;">1538548685500</td>
+<td style="text-align:center;">13.4</td>
+<td style="text-align:center;">223</td>
+<td style="text-align:center;">0.29</td>
+<td style="text-align:center;">Beijing.Haidian</td>
+<td style="text-align:center;">2</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1001</td>
+<td style="text-align:center;">1538548695000</td>
+<td style="text-align:center;">12.6</td>
+<td style="text-align:center;">218</td>
+<td style="text-align:center;">0.33</td>
+<td style="text-align:center;">Beijing.Chaoyang</td>
+<td style="text-align:center;">2</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1004</td>
+<td style="text-align:center;">1538548696600</td>
+<td style="text-align:center;">11.8</td>
+<td style="text-align:center;">221</td>
+<td style="text-align:center;">0.28</td>
+<td style="text-align:center;">Beijing.Haidian</td>
+<td style="text-align:center;">2</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1002</td>
+<td style="text-align:center;">1538548696650</td>
+<td style="text-align:center;">10.3</td>
+<td style="text-align:center;">218</td>
+<td style="text-align:center;">0.25</td>
+<td style="text-align:center;">Beijing.Chaoyang</td>
+<td style="text-align:center;">3</td>
+</tr>
+<tr>
+<td style="text-align:center;">d1001</td>
+<td style="text-align:center;">1538548696800</td>
+<td style="text-align:center;">12.3</td>
+<td style="text-align:center;">221</td>
+<td style="text-align:center;">0.31</td>
+<td style="text-align:center;">Beijing.Chaoyang</td>
+<td style="text-align:center;">2</td>
+</tr>
+</tbody>
+</table></figure>

 <center> 表1：智能电表数据示例</center>

@@ -221,7 +304,7 @@ TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），

 TDengine通过查询函数向用户提供毫秒级的数据获取能力。直接将最近到达的数据保存在缓存中，可以更加快速地响应用户针对最近一条或一批数据的查询分析，整体上提供更快的数据库查询响应能力。从这个意义上来说，**可通过设置合适的配置参数将TDengine作为数据缓存来使用，而不需要再部署Redis或其他额外的缓存系统**，可有效地简化系统架构，降低运维的成本。需要注意的是，TDengine重启以后系统的缓存将被清空，之前缓存的数据均会被批量写入磁盘，缓存的数据将不会像专门的Key-value缓存系统再将之前缓存的数据重新加载到缓存中。

-每个vnode有自己独立的内存，而且由多个固定大小的内存块组成，不同vnode之间完全隔离。数据写入时，类似于日志的写法，数据被顺序追加写入内存，但每个vnode维护有自己的skip list，便于迅速查找。当一半以上的内存块写满时，启动落盘操作，而且后续写的操作在新的内存块进行。这样，一个vnode里有一半内存块是保留有最近的数据的，以达到缓存、快速查找的目的。一个vnode的内存块的个数由配置参数blocks决定，内存块的大小由配置参数cache决定。
+每个vnode有自己独立的内存，而且由多个固定大小的内存块组成，不同vnode之间完全隔离。数据写入时，类似于日志的写法，数据被顺序追加写入内存，但每个vnode维护有自己的skip list，便于迅速查找。当三分之一以上的内存块写满时，启动落盘操作，而且后续写的操作在新的内存块进行。这样，一个vnode里有三分之一内存块是保留有最近的数据的，以达到缓存、快速查找的目的。一个vnode的内存块的个数由配置参数blocks决定，内存块的大小由配置参数cache决定。

 ### 持久化存储
 TDengine采用数据驱动的方式让缓存中的数据写入硬盘进行持久化存储。当vnode中缓存的数据达到一定规模时，为了不阻塞后续数据的写入，TDengine也会拉起落盘线程将缓存的数据写入持久化存储。TDengine在数据落盘时会打开新的数据库日志文件，在落盘成功后则会删除老的数据库日志文件，避免日志文件无限制的增长。

--- a/documentation20/webdocs/markdowndocs/connector-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-ch.md
@@ -616,6 +616,43 @@ HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间
 - httpEnableCompress: 是否支持压缩，默认不支持，目前TDengine仅支持gzip压缩格式
 - httpDebugFlag: 日志开关，131：仅错误和报警信息，135：调试信息，143：非常详细的调试信息，默认131

+## CSharp Connector
+
+在Windows系统上，C#应用程序可以使用TDengine的原生C接口来执行所有数据库操作，后续版本将提供ORM（dapper）框架驱动。
+
+#### 安装TDengine客户端
+
+C#连接器需要使用`libtaos.so`和`taos.h`。因此，在使用C#连接器之前，需在程序运行的Windows环境安装TDengine的Windows客户端，以便获得相关驱动文件。
+
+安装完成后，在文件夹`C:/TDengine/examples/C#`中，将会看到两个文件
+
+- TDengineDriver.cs 调用taos.dll文件的Native C方法
+- TDengineTest.cs 参考程序示例
+
+在文件夹`C:\Windows\System32`，将会看到`taos.dll`文件
+
+#### 使用方法
+
+- 将C#接口文件TDengineDriver.cs加入到应用程序所在.NET项目中
+- 参考TDengineTest.cs来定义数据库连接参数，及执行数据插入、查询等操作的方法
+- 因为C#接口需要用到`taos.dll`文件，用户可以将`taos.dll`文件加入.NET解决方案中
+
+#### 注意事项
+
+- `taos.dll`文件使用x64平台编译，所以.NET项目在生成.exe文件时，“解决方案”/“项目”的“平台”请均选择“x64”。
+- 此.NET接口目前已经在Visual Studio 2013/2015/2017中验证过，其它VS版本尚待验证。
+
+#### 第三方驱动
+
+Maikebing.Data.Taos是一个TDengine的ADO.Net提供器，支持linux，windows。该开发包由热心贡献者`麦壳饼@@maikebing`提供，具体请参考
+
+```
+//接口下载
+https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos   
+//用法说明    
+https://www.taosdata.com/blog/2020/11/02/1901.html                    
+```
+

 ## Go Connector


--- a/documentation20/webdocs/markdowndocs/faq-ch.md
+++ b/documentation20/webdocs/markdowndocs/faq-ch.md
@@ -38,9 +38,9 @@

 6. 检查防火墙设置，确认TCP/UDP 端口6030-6042 是打开的

-7. 对于Linux上的JDBC（ODBC, Python, Go等接口类似）连接, 确保*libtaos.so*在目录*/usr/local/lib/taos*里, 并且*/usr/local/lib/taos*在系统库函数搜索路径*LD_LIBRARY_PATH*里 
+7. 对于Linux上的JDBC（ODBC, Python, Go等接口类似）连接, 确保*libtaos.so*在目录*/usr/local/taos/driver*里, 并且*/usr/local/taos/driver*在系统库函数搜索路径*LD_LIBRARY_PATH*里 

-8. 对于windows上的JDBC, ODBC, Python, Go等连接，确保*driver/c/taos.dll*在你的系统搜索目录里 (建议*taos.dll*放在目录 *C:\Windows\System32*)
+8. 对于windows上的JDBC, ODBC, Python, Go等连接，确保*C:\TDengine\driver\taos.dll*在你的系统库函数搜索目录里 (建议*taos.dll*放在目录 *C:\Windows\System32*)

 9. 如果仍不能排除连接故障，请使用命令行工具nc来分别判断指定端口的TCP和UDP连接是否通畅
   检查UDP端口连接是否工作：`nc -vuz {hostIP} {port} `

--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/webdocs/markdowndocs/insert-ch.md
 # 高效写入数据

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

 ## SQL写入

@@ -218,7 +218,15 @@ use telegraf;
 select * from cpu;
 ```

-## EMQ X Broker直接写入

-MQTT是一流行的物联网数据传输协议，[EMQ](https://github.com/emqx/emqx)是一开源的MQTT Broker软件，无需任何代码，只需要在EMQ Dashboard里使用“规则”做简单配置，即可将MQTT的数据直接写入TDengine。EMQ X 支持通过 发送到 Web 服务 的方式保存数据到 TDEngine，也在企业版上提供原生的 TDEngine 驱动实现直接保存。详细使用方法请参考 [EMQ 官方文档](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
+
+MQTT是一流行的物联网数据传输协议，TDengine 可以很方便的接入 MQTT Broker 接受的数据并写入到 TDengine。
+
+## EMQ Broker 直接写入
+
+[EMQ](https://github.com/emqx/emqx)是一开源的MQTT Broker软件，无需任何代码，只需要在EMQ Dashboard里使用“规则”做简单配置，即可将MQTT的数据直接写入TDengine。EMQ X 支持通过 发送到 Web 服务 的方式保存数据到 TDengine，也在企业版上提供原生的 TDEngine 驱动实现直接保存。详细使用方法请参考 [EMQ 官方文档](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
+
+## HiveMQ Broker 直接写入
+
+[HiveMQ](https://www.hivemq.com/) 是一个提供免费个人版和企业版的 MQTT 代理，主要用于企业和新兴的机器到机器M2M通讯和内部传输，满足可伸缩性、易管理和安全特性。HiveMQ 提供了开源的插件开发包。可以通过 HiveMQ extension - TDengine 保存数据到 TDengine。详细使用方法请参考 [HiveMQ extension - TDengine 说明文档](https://github.com/huskar-t/hivemq-tdengine-extension/blob/b62a26ecc164a310104df57691691b237e091c89/README.md)。

--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -20,6 +20,9 @@
 # data file's directory
 # dataDir                   /var/lib/taos

+# temporary file's directory
+# tempDir                   /tmp/
+
 # the arbitrator's fully qualified domain name (FQDN) for TDengine system, for cluster only   
 # arbitrator                arbitrator_hostname:6042     

@@ -256,3 +259,5 @@
 # maximum display width of binary and nchar fields in the shell. The parts exceeding this limit will be hidden
 # maxBinaryDisplayWidth 30

+# enable/disable telemetry reporting
+# telemetryReporting    1
\ No newline at end of file
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -48,6 +48,7 @@ cp ${compile_dir}/../packaging/deb/taosd            ${pkg_dir}${install_home_pat
 cp ${compile_dir}/../packaging/tools/post.sh        ${pkg_dir}${install_home_path}/script
 cp ${compile_dir}/../packaging/tools/preun.sh       ${pkg_dir}${install_home_path}/script
 cp ${compile_dir}/build/bin/taosdemo                ${pkg_dir}${install_home_path}/bin
+cp ${compile_dir}/build/bin/taosdump                ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/bin/taosd                   ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/bin/taos                    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_path}/driver 
@@ -58,7 +59,7 @@ cp -r ${top_dir}/src/connector/grafanaplugin        ${pkg_dir}${install_home_pat
 cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/go                   ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/nodejs               ${pkg_dir}${install_home_path}/connector
-cp ${compile_dir}/build/lib/taos-jdbcdriver*dist.*  ${pkg_dir}${install_home_path}/connector
+cp ${compile_dir}/build/lib/taos-jdbcdriver*dist.*  ${pkg_dir}${install_home_path}/connector ||:

 cp -r ${compile_dir}/../packaging/deb/DEBIAN        ${pkg_dir}/
 chmod 755 ${pkg_dir}/DEBIAN/*

--- a/packaging/release.sh
+++ b/packaging/release.sh
@@ -156,9 +156,15 @@ build_time=$(date +"%F %R")

 # get commint id from git
 gitinfo=$(git rev-parse --verify HEAD)
-enterprise_dir="${top_dir}/../enterprise"
-cd ${enterprise_dir}
-gitinfoOfInternal=$(git rev-parse --verify HEAD)
+
+if [[ "$verMode" == "cluster" ]]; then
+  enterprise_dir="${top_dir}/../enterprise"
+  cd ${enterprise_dir}
+  gitinfoOfInternal=$(git rev-parse --verify HEAD)
+else
+  gitinfoOfInternal=NULL
+fi
+  
 cd ${curr_dir}

 # 2. cmake executable file
@@ -193,23 +199,35 @@ cd ${curr_dir}
 # 3. Call the corresponding script for packaging
 if [ "$osType" != "Darwin" ]; then
  if [[ "$verMode" != "cluster" ]] && [[ "$cpuType" == "x64" ]] && [[ "$dbName" == "taos" ]]; then
-    echo "====do deb package for the ubuntu system===="
-    output_dir="${top_dir}/debs"
-    if [ -d ${output_dir} ]; then
-      ${csudo} rm -rf ${output_dir}
+    ret='0'    
+    command -v dpkg >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then  
+      echo "====do deb package for the ubuntu system===="
+      output_dir="${top_dir}/debs"
+      if [ -d ${output_dir} ]; then
+        ${csudo} rm -rf ${output_dir}
+      fi
+      ${csudo} mkdir -p ${output_dir}
+      cd ${script_dir}/deb
+      ${csudo} ./makedeb.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
+    else
+      echo "==========dpkg command not exist, so not release deb package!!!"
    fi
-    ${csudo} mkdir -p ${output_dir}
-    cd ${script_dir}/deb
-    ${csudo} ./makedeb.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
-
-    echo "====do rpm package for the centos system===="
-    output_dir="${top_dir}/rpms"
-    if [ -d ${output_dir} ]; then
-      ${csudo} rm -rf ${output_dir}
+
+    ret='0'    
+    command -v rpmbuild >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then  
+      echo "====do rpm package for the centos system===="
+      output_dir="${top_dir}/rpms"
+      if [ -d ${output_dir} ]; then
+        ${csudo} rm -rf ${output_dir}
+      fi
+      ${csudo} mkdir -p ${output_dir}
+      cd ${script_dir}/rpm
+      ${csudo} ./makerpm.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
+    else
+      echo "==========rpmbuild command not exist, so not release rpm package!!!"
    fi
-    ${csudo} mkdir -p ${output_dir}
-    cd ${script_dir}/rpm
-    ${csudo} ./makerpm.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
  fi
 	
  echo "====do tar.gz package for all systems===="

--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@@ -2,7 +2,7 @@
 %define cfg_install_dir  /etc/taos
 %define __strip /bin/true

-Name:		TDengine
+Name:		tdengine
 Version:	%{_version}
 Release:	3%{?dist}
 Summary:	tdengine from taosdata
@@ -58,6 +58,7 @@ cp %{_compiledir}/../packaging/tools/preun.sh       %{buildroot}%{homepath}/scri
 cp %{_compiledir}/build/bin/taos                    %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taosd                   %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taosdemo                %{buildroot}%{homepath}/bin
+cp %{_compiledir}/build/bin/taosdump                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
 cp %{_compiledir}/../src/inc/taos.h                 %{buildroot}%{homepath}/include
 cp %{_compiledir}/../src/inc/taoserror.h            %{buildroot}%{homepath}/include
@@ -65,7 +66,7 @@ cp -r %{_compiledir}/../src/connector/grafanaplugin %{buildroot}%{homepath}/conn
 cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/nodejs        %{buildroot}%{homepath}/connector
-cp %{_compiledir}/build/lib/taos-jdbcdriver*dist.*  %{buildroot}%{homepath}/connector
+cp %{_compiledir}/build/lib/taos-jdbcdriver*dist.*  %{buildroot}%{homepath}/connector ||:
 cp -r %{_compiledir}/../tests/examples/*            %{buildroot}%{homepath}/examples

 #Scripts executed before installation
@@ -134,6 +135,7 @@ if [ $1 -eq 0 ];then
    ${csudo} rm -f ${bin_link_dir}/taos       || :
    ${csudo} rm -f ${bin_link_dir}/taosd      || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo   || :
+    #${csudo} rm -f ${bin_link_dir}/taosdump   || :
    ${csudo} rm -f ${cfg_link_dir}/*          || :
    ${csudo} rm -f ${inc_link_dir}/taos.h     || :
    ${csudo} rm -f ${inc_link_dir}/taoserror.h     || :

--- a/packaging/tools/get_client.sh
+++ b/packaging/tools/get_client.sh
+#!/bin/bash
+#
+
+log_dir=$1
+result_file=$2
+
+if [ ! -n "$1" ];then
+  echo "Pleas input the director of taosdlog."
+  echo "usage: ./get_client.sh <taosdlog directory> <result file>"
+  exit 1
+else
+  log_dir=$1
+fi
+
+if [ ! -n "$2" ];then
+  result_file=clientInfo.txt
+else
+  result_file=$2
+fi
+
+grep "new TCP connection" ${log_dir}/taosdlog.* | sed -e "s/0x.* from / /"|sed -e "s/,.*$//"|sed -e "s/:[0-9]*$//"|sort -r|uniq -f 2|sort -k 3 -r|uniq -f 2 > ${result_file}
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -278,11 +278,11 @@ function install_service_on_sysvinit() {

    # Install taosd service
    if ((${os_type}==1)); then
-    ${csudo} cp -f ${script_dir}/../deb/init.d/taosd ${install_main_dir}/init.d
-    ${csudo} cp    ${script_dir}/../deb/init.d/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
+    ${csudo} cp -f ${script_dir}/../deb/taosd ${install_main_dir}/init.d
+    ${csudo} cp    ${script_dir}/../deb/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
    elif ((${os_type}==2)); then
-    ${csudo} cp -f ${script_dir}/../rpm/init.d/taosd ${install_main_dir}/init.d
-    ${csudo} cp    ${script_dir}/../rpm/init.d/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
+    ${csudo} cp -f ${script_dir}/../rpm/taosd ${install_main_dir}/init.d
+    ${csudo} cp    ${script_dir}/../rpm/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
    fi
    
    #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"

--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@@ -45,7 +45,7 @@ if [ "$osType" != "Darwin" ]; then
    strip ${build_dir}/bin/taos
    bin_files="${build_dir}/bin/taos ${script_dir}/remove_client.sh"
  else  
-    bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdemo ${script_dir}/remove_client.sh ${script_dir}/set_core.sh"
+    bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo ${script_dir}/remove_client.sh ${script_dir}/set_core.sh ${script_dir}/get_client.sh"
  fi
  lib_files="${build_dir}/lib/libtaos.so.${version}"
 else
@@ -110,7 +110,7 @@ mkdir -p ${install_dir}/connector

 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
  if [ "$osType" != "Darwin" ]; then
-    cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+    cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
  fi
  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
  cp -r ${connector_dir}/python        ${install_dir}/connector/

--- a/packaging/tools/makeclient_power.sh
+++ b/packaging/tools/makeclient_power.sh
@@ -76,8 +76,10 @@ if [ "$osType" != "Darwin" ]; then
  else 
    cp ${build_dir}/bin/taos          ${install_dir}/bin/power
    cp ${script_dir}/remove_power.sh  ${install_dir}/bin
-    cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/powerdemo   
+    cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/powerdemo 
+    cp ${build_dir}/bin/taosdump      ${install_dir}/bin/powerdump  
    cp ${script_dir}/set_core.sh      ${install_dir}/bin
+    cp ${script_dir}/get_client.sh    ${install_dir}/bin
  fi
 else
  cp ${bin_files} ${install_dir}/bin
@@ -135,7 +137,7 @@ mkdir -p ${install_dir}/connector

 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
  if [ "$osType" != "Darwin" ]; then
-    cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+    cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
  fi
  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
  cp -r ${connector_dir}/python  ${install_dir}/connector/

--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -36,7 +36,7 @@ if [ "$pagMode" == "lite" ]; then
  strip ${build_dir}/bin/taos
  bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${script_dir}/remove.sh"
 else 
-  bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdemo ${build_dir}/bin/tarbitrator ${script_dir}/remove.sh ${script_dir}/set_core.sh"
+  bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo ${build_dir}/bin/tarbitrator ${script_dir}/remove.sh ${script_dir}/set_core.sh ${script_dir}/get_client.sh"
 fi

 lib_files="${build_dir}/lib/libtaos.so.${version}"
@@ -124,7 +124,7 @@ cp ${lib_files} ${install_dir}/driver
 connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar            ${install_dir}/connector
+  cp ${build_dir}/lib/*.jar            ${install_dir}/connector ||:
  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
  cp -r ${connector_dir}/python        ${install_dir}/connector/
  cp -r ${connector_dir}/go            ${install_dir}/connector

--- a/packaging/tools/makepkg_power.sh
+++ b/packaging/tools/makepkg_power.sh
@@ -77,8 +77,10 @@ else
  cp ${build_dir}/bin/taosd         ${install_dir}/bin/powerd
  cp ${script_dir}/remove_power.sh  ${install_dir}/bin
  cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/powerdemo   
+  cp ${build_dir}/bin/taosdump      ${install_dir}/bin/powerdump  
  cp ${build_dir}/bin/tarbitrator   ${install_dir}/bin
  cp ${script_dir}/set_core.sh      ${install_dir}/bin
+  cp ${script_dir}/get_client.sh    ${install_dir}/bin
 fi
 chmod a+x ${install_dir}/bin/* || :

@@ -156,7 +158,7 @@ cp ${lib_files} ${install_dir}/driver
 connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
  cp -r ${connector_dir}/python  ${install_dir}/connector/
  cp -r ${connector_dir}/go      ${install_dir}/connector

--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@@ -81,8 +81,10 @@ function install_lib() {
    ${csudo} ln -s ${lib_dir}/libtaos.* ${lib_link_dir}/libtaos.so.1
    ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
    
-    ${csudo} ln -s ${lib_dir}/libtaos.* ${lib64_link_dir}/libtaos.so.1           || :
-    ${csudo} ln -s ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so   || :
+    if [[ -d ${lib64_link_dir} && ! -e ${lib64_link_dir}/libtaos.so ]]; then
+      ${csudo} ln -s ${lib_dir}/libtaos.* ${lib64_link_dir}/libtaos.so.1           || :
+      ${csudo} ln -s ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so   || :
+    fi
 }

 function install_bin() {
@@ -121,8 +123,11 @@ function install_config() {
    echo -e -n "${GREEN}Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join${NC}"
    echo
    echo -e -n "${GREEN}OR leave it blank to build one${NC}:"
-    read firstEp
-    while true; do
+    #read firstEp
+    if exec < /dev/tty; then
+    	read firstEp;
+	fi
+	while true; do
        if [ ! -z "$firstEp" ]; then
            # check the format of the firstEp
            #if [[ $firstEp == $FQDN_PATTERN ]]; then

--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
 name: tdengine
 base: core18
-version: '2.0.5.1'
+version: '2.0.7.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
      - usr/bin/taosd
      - usr/bin/taos
      - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.5.1
+      - usr/lib/libtaos.so.2.0.6.0
      - usr/lib/libtaos.so.1
      - usr/lib/libtaos.so


--- a/src/balance/src/balance.c
+++ b/src/balance/src/balance.c
@@ -490,7 +490,7 @@ static bool balanceMontiorDropping() {

    if (pDnode->status == TAOS_DN_STATUS_OFFLINE) {
      if (pDnode->lastAccess + tsOfflineThreshold > tsAccessSquence) continue;
-      if (strcmp(pDnode->dnodeEp, dnodeGetMnodeMasterEp()) == 0) continue; 
+      if (dnodeIsMasterEp(pDnode->dnodeEp)) continue; 
      if (mnodeGetDnodesNum() <= 1) continue;

      mLInfo("dnode:%d, set to removing state for it offline:%d seconds", pDnode->dnodeId,
@@ -571,8 +571,8 @@ static void balanceCheckDnodeAccess() {
      if (pDnode->status != TAOS_DN_STATUS_DROPPING && pDnode->status != TAOS_DN_STATUS_OFFLINE) {
        pDnode->status = TAOS_DN_STATUS_OFFLINE;
        pDnode->offlineReason = TAOS_DN_OFF_STATUS_MSG_TIMEOUT;
-        mInfo("dnode:%d, set to offline state, access seq:%d, last seq:%d", pDnode->dnodeId, tsAccessSquence,
-              pDnode->lastAccess);
+        mInfo("dnode:%d, set to offline state, access seq:%d last seq:%d laststat:%d", pDnode->dnodeId, tsAccessSquence,
+              pDnode->lastAccess, pDnode->status);
        balanceSetVgroupOffline(pDnode);
      }
    }

--- a/src/client/inc/tscLocalMerge.h
+++ b/src/client/inc/tscLocalMerge.h
@@ -62,11 +62,11 @@ typedef struct SLocalReducer {
  bool                   hasUnprocessedRow;
  tOrderDescriptor *     pDesc;
  SColumnModel *         resColModel;
+  SColumnModel*          finalModel;
  tExtMemBuffer **       pExtMemBuffer;      // disk-based buffer
  SFillInfo*             pFillInfo;          // interpolation support structure
-  char *                 pFinalRes;          // result data after interpo
-  tFilePage *            discardData;
-  SResultInfo *          pResInfo;
+  char*                  pFinalRes;          // result data after interpo
+  tFilePage*             discardData;
  bool                   discard;
  int32_t                offset;             // limit offset value
  bool                   orderPrjOnSTable;   // projection query on stable
@@ -75,7 +75,8 @@ typedef struct SLocalReducer {
 typedef struct SRetrieveSupport {
  tExtMemBuffer **  pExtMemBuffer;     // for build loser tree
  tOrderDescriptor *pOrderDescriptor;
-  SColumnModel *    pFinalColModel;    // colModel for final result
+  SColumnModel*     pFinalColModel;    // colModel for final result
+  SColumnModel*     pFFColModel;
  int32_t           subqueryIndex;     // index of current vnode in vnode list
  SSqlObj *         pParentSql;
  tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
@@ -97,7 +98,7 @@ int32_t tscFlushTmpBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tF
 * create local reducer to launch the second-stage reduce process at client site
 */
 void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                           SColumnModel *finalModel, SSqlObj* pSql);
+                           SColumnModel *finalModel, SColumnModel *pFFModel, SSqlObj* pSql);

 void tscDestroyLocalReducer(SSqlObj *pSql);


--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -23,7 +23,7 @@ extern "C" {
 #include "tscUtil.h"
 #include "tsclient.h"

-void tscFetchDatablockFromSubquery(SSqlObj* pSql);
+void tscFetchDatablockForSubquery(SSqlObj* pSql);

 void tscSetupOutputColumnIndex(SSqlObj* pSql);
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code);
@@ -41,6 +41,8 @@ int32_t tscHandleInsertRetry(SSqlObj* pSql);
 void tscBuildResFromSubqueries(SSqlObj *pSql);
 TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult);

+char *getArithemicInputSrc(void *param, const char *name, int32_t colId);
+
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -75,6 +75,7 @@ typedef struct SJoinSupporter {
  SArray*         exprList;
  SFieldInfo      fieldsInfo;
  STagCond        tagCond;
+  SSqlGroupbyExpr groupInfo;       // group by info
  struct STSBuf*  pTSBuf;          // the TSBuf struct that holds the compressed timestamp array
  FILE*           f;               // temporary file in order to create TSBuf
  char            path[PATH_MAX];  // temporary file path, todo dynamic allocate memory
@@ -86,8 +87,8 @@ typedef struct SJoinSupporter {
 } SJoinSupporter;

 typedef struct SVgroupTableInfo {
-  SCMVgroupInfo vgInfo;
-  SArray*       itemList;   //SArray<STableIdInfo>
+  SVgroupInfo vgInfo;
+  SArray*     itemList;   //SArray<STableIdInfo>
 } SVgroupTableInfo;

 static FORCE_INLINE SQueryInfo* tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex) {
@@ -124,6 +125,7 @@ int32_t tscGetDataBlockFromList(void* pHashList, SArray* pDataBlockList, int64_t
 */
 bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
+bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);

 bool tscNonOrderedProjectionQueryOnSTable(SQueryInfo *pQueryInfo, int32_t tableIndex);
 bool tscOrderedProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
@@ -157,7 +159,7 @@ SInternalField* tscFieldInfoGetInternalField(SFieldInfo* pFieldInfo, int32_t ind
 TAOS_FIELD* tscFieldInfoGetField(SFieldInfo* pFieldInfo, int32_t index);

 void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
-void tscFieldInfoUpdateOffsetForInterResult(SQueryInfo* pQueryInfo);
+void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);

 int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
 void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
@@ -166,15 +168,15 @@ static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQue

 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);

-void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes, int16_t tableIndex);
+void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);

 int32_t   tscGetResRowLength(SArray* pExprList);

 SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-    int16_t size, int16_t interSize, bool isTagCol);
+    int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);

 SSqlExpr* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-                           int16_t size, int16_t interSize, bool isTagCol);
+                           int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);

 SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                           int16_t size);
@@ -225,8 +227,9 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo);

 void tscClearSubqueryInfo(SSqlCmd* pCmd);
 void tscFreeVgroupTableInfo(SArray* pVgroupTables);
-SArray* tscCloneVgroupTableInfo(SArray* pVgroupTables);
+SArray* tscVgroupTableInfoClone(SArray* pVgroupTables);
 void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index);
+void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);

 int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
@@ -237,7 +240,7 @@ void tscDoQuery(SSqlObj* pSql);

 SVgroupsInfo* tscVgroupInfoClone(SVgroupsInfo *pInfo);
 void* tscVgroupInfoClear(SVgroupsInfo *pInfo);
-void tscSCMVgroupInfoCopy(SCMVgroupInfo* dst, const SCMVgroupInfo* src);
+void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src);
 /**
 * The create object function must be successful expect for the out of memory issue.
 *
@@ -265,6 +268,7 @@ void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t sub
 void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);

 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid);
+int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId);

 void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex);


--- a/src/client/inc/tschemautil.h
+++ b/src/client/inc/tschemautil.h
@@ -77,7 +77,7 @@ SSchema *tscGetTableColumnSchema(const STableMeta *pMeta, int32_t colIndex);
 * @param colId
 * @return
 */
-SSchema* tscGetTableColumnSchemaById(STableMeta* pTableMeta, int16_t colId);
+SSchema* tscGetColumnSchemaById(STableMeta* pTableMeta, int16_t colId);

 /**
 * check if the schema is valid or not, including following aspects:
@@ -107,9 +107,6 @@ SSchema tscGetTbnameColumnSchema();
 */
 STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size);

-//todo tags value as well as the table id structure needs refactor
-char *tsGetTagsValue(STableMeta *pMeta);
-
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -30,6 +30,7 @@ extern "C" {
 #include "tsqlfunction.h"
 #include "tutil.h"
 #include "tcache.h"
+#include "tref.h"

 #include "qExecutor.h"
 #include "qSqlparser.h"
@@ -89,12 +90,12 @@ typedef struct STableComInfo {
  int32_t rowSize;
 } STableComInfo;

-typedef struct SCMCorVgroupInfo {
-  int32_t    version;
-  int8_t     inUse;
-  int8_t     numOfEps;
-  SEpAddr1   epAddr[TSDB_MAX_REPLICA];
-} SCMCorVgroupInfo;
+typedef struct SCorVgroupInfo {
+  int32_t  version;
+  int8_t   inUse;
+  int8_t   numOfEps;
+  SEpAddr1 epAddr[TSDB_MAX_REPLICA];
+} SCorVgroupInfo;

 typedef struct STableMeta {
  STableComInfo  tableInfo;
@@ -102,8 +103,8 @@ typedef struct STableMeta {
  int16_t        sversion;
  int16_t        tversion;
  char           sTableId[TSDB_TABLE_FNAME_LEN];
-  SCMVgroupInfo  vgroupInfo;
-  SCMCorVgroupInfo  corVgroupInfo;
+  SVgroupInfo    vgroupInfo;
+  SCorVgroupInfo corVgroupInfo;
  STableId       id;
  SSchema        schema[];  // if the table is TSDB_CHILD_TABLE, schema is acquired by super table meta info
 } STableMeta;
@@ -127,7 +128,7 @@ typedef struct STableMetaInfo {
 typedef struct SSqlExpr {
  char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
  SColIndex colInfo;
-  int64_t   uid;            // refactor use the pointer
+  uint64_t  uid;            // refactor use the pointer
  int16_t   functionId;     // function id in aAgg array
  int16_t   resType;        // return value type
  int16_t   resBytes;       // length of return value
@@ -135,6 +136,7 @@ typedef struct SSqlExpr {
  int16_t   numOfParams;    // argument value of each function
  tVariant  param[3];       // parameters are not more than 3
  int32_t   offset;         // sub result column value of arithmetic expression.
+  int16_t   resColId;          // result column id
 } SSqlExpr;

 typedef struct SColumnIndex {
@@ -250,6 +252,7 @@ typedef struct SQueryInfo {
  int64_t          clauseLimit;   // limit for current sub clause
  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
+  int16_t          resColumnId;   // result column id
 } SQueryInfo;

 typedef struct {
@@ -329,6 +332,7 @@ typedef struct STscObj {
  char               writeAuth : 1;
  char               superAuth : 1;
  uint32_t           connId;
+  uint64_t           rid;      // ref ID returned by taosAddRef
  struct SSqlObj *   pHb;
  struct SSqlObj *   sqlList;
  struct SSqlStream *streamList;
@@ -338,16 +342,16 @@ typedef struct STscObj {
 } STscObj;

 typedef struct SSubqueryState {
-  int32_t          numOfRemain;         // the number of remain unfinished subquery
-  int32_t          numOfSub;            // the number of total sub-queries
-  uint64_t         numOfRetrievedRows;  // total number of points in this query
+  int32_t  numOfRemain;         // the number of remain unfinished subquery
+  int32_t  numOfSub;            // the number of total sub-queries
+  uint64_t numOfRetrievedRows;  // total number of points in this query
 } SSubqueryState;

 typedef struct SSqlObj {
  void            *signature;
  pthread_t        owner;        // owner of sql object, by which it is executed
  STscObj         *pTscObj;
-  void            *pRpcCtx;
+  int64_t          rpcRid;
  void            (*fp)();
  void            (*fetchFp)();
  void            *param;
@@ -430,14 +434,6 @@ void tscResetSqlCmdObj(SSqlCmd *pCmd, bool removeFromCache);
 */
 void tscFreeSqlResult(SSqlObj *pSql);

-/**
- * only free part of resources allocated during query.
- * TODO remove it later
- * Note: this function is multi-thread safe.
- * @param pObj
- */
-void tscPartiallyFreeSqlObj(SSqlObj *pSql);
-
 /**
 * free sql object, release allocated resource
 * @param pObj
@@ -446,7 +442,7 @@ void tscFreeSqlObj(SSqlObj *pSql);
 void tscFreeRegisteredSqlObj(void *pSql);
 void tscFreeTableMetaHelper(void *pTableMeta);

-void tscCloseTscObj(STscObj *pObj);
+void tscCloseTscObj(void *pObj);

 // todo move to taos? or create a new file: taos_internal.h
 TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
@@ -468,17 +464,16 @@ int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* s

 int32_t tscToSQLCmd(SSqlObj *pSql, struct SSqlInfo *pInfo);

-static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pFieldInfo, int32_t columnIndex) {
+static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pFieldInfo, int32_t columnIndex, int32_t offset) {
  SInternalField* pInfo = (SInternalField*) TARRAY_GET_ELEM(pFieldInfo->internalField, columnIndex);
-  assert(pInfo->pSqlExpr != NULL);

-  int32_t type = pInfo->pSqlExpr->resType;
-  int32_t bytes = pInfo->pSqlExpr->resBytes;
+  int32_t type = pInfo->field.type;
+  int32_t bytes = pInfo->field.bytes;

-  char* pData = pRes->data + (int32_t)(pInfo->pSqlExpr->offset * pRes->numOfRows + bytes * pRes->row);
+  char* pData = pRes->data + (int32_t)(offset * pRes->numOfRows + bytes * pRes->row);

  // user defined constant value output columns
-  if (TSDB_COL_IS_UD_COL(pInfo->pSqlExpr->colInfo.flag)) {
+  if (pInfo->pSqlExpr != NULL && TSDB_COL_IS_UD_COL(pInfo->pSqlExpr->colInfo.flag)) {
    if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
      pData = pInfo->pSqlExpr->param[1].pz;
      pRes->length[columnIndex] = pInfo->pSqlExpr->param[1].nLen;
@@ -516,13 +511,14 @@ extern void *    tscQhandle;
 extern int       tscKeepConn[];
 extern int       tsInsertHeadSize;
 extern int       tscNumOfThreads;
+extern int       tscRefId;
  
 extern SRpcCorEpSet tscMgmtEpSet;

 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);

-int32_t tscCompareTidTags(const void* p1, const void* p2);
 void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArray* tables);
+int16_t getNewResColId(SQueryInfo* pQueryInfo);

 #ifdef __cplusplus
 }

--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -176,7 +176,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
  }

  if (pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE) {
-    tscFetchDatablockFromSubquery(pSql);
+    tscFetchDatablockForSubquery(pSql);
  } else {
    tscProcessSql(pSql);
  }
@@ -226,7 +226,7 @@ void taos_fetch_rows_a(TAOS_RES *taosa, __async_cb_func_t fp, void *param) {
  
  // handle the sub queries of join query
  if (pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE) {
-    tscFetchDatablockFromSubquery(pSql);
+    tscFetchDatablockForSubquery(pSql);
  } else if (pRes->completed) {
    if(pCmd->command == TSDB_SQL_FETCH || (pCmd->command >= TSDB_SQL_SERV_STATUS && pCmd->command <= TSDB_SQL_CURRENT_USER)) {
      if (hasMoreVnodesToTry(pSql)) {  // sequentially retrieve data from remain vnodes.
@@ -351,7 +351,7 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
    SInternalField* pSup = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);

    if (pSup->pSqlExpr != NULL) {
-      tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i);
+      tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i, 0);
    } else {
 //      todo add
    }
@@ -405,7 +405,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
  SSqlRes *pRes = &pSql->res;
  pRes->code = code;

-  const char* msg = (pCmd->command == TSDB_SQL_STABLEVGROUP)? "vgroup-list":"table-meta";
+  SSqlObj *sub = (SSqlObj*) res;
+  const char* msg = (sub->cmd.command == TSDB_SQL_STABLEVGROUP)? "vgroup-list":"table-meta";
  if (code != TSDB_CODE_SUCCESS) {
    tscError("%p get %s failed, code:%s", pSql, msg, tstrerror(code));
    goto _error;
@@ -427,8 +428,12 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      } else {
        assert(code == TSDB_CODE_SUCCESS);      
      }
-     
-      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0) && pSql->param != NULL);
+
+      // param already freed by other routine and pSql in tscCache when ctrl + c 
+      if (atomic_load_ptr(&pSql->param) == NULL) {
+        return;
+      }
+      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));

      SRetrieveSupport *trs = (SRetrieveSupport *)pSql->param;
      SSqlObj *         pParObj = trs->pParentSql;
@@ -437,6 +442,20 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      assert(pParObj->signature == pParObj && trs->subqueryIndex == pTableMetaInfo->vgroupIndex &&
          pTableMetaInfo->vgroupIndex >= 0 && pTableMetaInfo->vgroupList != NULL);

+      // tscProcessSql can add error into async res
+      tscProcessSql(pSql);
+      return;
+    } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) {
+      tscDebug("%p update table meta in local cache, continue to process sql and send corresponding tid_tag query", pSql);
+      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+      code = tscGetTableMeta(pSql, pTableMetaInfo);
+      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+        return;
+      } else {
+        assert(code == TSDB_CODE_SUCCESS);
+      }
+
+      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));
      // tscProcessSql can add error into async res
      tscProcessSql(pSql);
      return;
@@ -461,7 +480,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
          tscResetSqlCmdObj(pCmd, false);

          code = tsParseSql(pSql, true);
-
          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
            return;
          } else if (code != TSDB_CODE_SUCCESS) {

--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -49,82 +49,6 @@ typedef struct SCreateBuilder {
 } SCreateBuilder; 
 static void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnName, int16_t type, size_t valueLength);

-static int32_t getToStringLength(const char *pData, int32_t length, int32_t type) {
-  char buf[512] = {0};
-
-  int32_t len = 0;
-  int32_t MAX_BOOL_TYPE_LENGTH = 5;  // max(strlen("true"), strlen("false"));
-  switch (type) {
-    case TSDB_DATA_TYPE_BINARY:
-      return length;
-    case TSDB_DATA_TYPE_NCHAR:
-      return length;
-    case TSDB_DATA_TYPE_DOUBLE: {
-      double dv = 0;
-      dv = GET_DOUBLE_VAL(pData);
-      len = sprintf(buf, "%lf", dv);
-      if (strncasecmp("nan", buf, 3) == 0) {
-        len = 4;
-      }
-    } break;
-    case TSDB_DATA_TYPE_FLOAT: {
-      float fv = 0;
-      fv = GET_FLOAT_VAL(pData);
-      len = sprintf(buf, "%f", fv);
-      if (strncasecmp("nan", buf, 3) == 0) {
-        len = 4;
-      }
-    } break;
-    case TSDB_DATA_TYPE_TIMESTAMP:
-    case TSDB_DATA_TYPE_BIGINT:
-      len = sprintf(buf, "%" PRId64, *(int64_t *)pData);
-      break;
-    case TSDB_DATA_TYPE_BOOL:
-      len = MAX_BOOL_TYPE_LENGTH;
-      break;
-    default:
-      len = sprintf(buf, "%d", *(int32_t *)pData);
-      break;
-  };
-  return len;
-}
-
-/*
- * we need to convert all data into string, so we need to sprintf all kinds of
- * non-string data into string, and record its length to get the right
- * maximum length. The length may be less or greater than its original binary length:
- * For example:
- * length((short) 1) == 1, less than sizeof(short)
- * length((uint64_t) 123456789011) > 12, greater than sizsof(uint64_t)
- */
-static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) {
-  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0)->pTableMeta;
-
-  if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
-      pMeta->tableType == TSDB_STREAM_TABLE) {
-    return 0;
-  }
-
-  char *   pTagValue = tsGetTagsValue(pMeta);
-  SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
-
-  int32_t len = getToStringLength(pTagValue, pTagsSchema[0].bytes, pTagsSchema[0].type);
-
-  pTagValue += pTagsSchema[0].bytes;
-  int32_t numOfTags = tscGetNumOfTags(pMeta);
-  
-  for (int32_t i = 1; i < numOfTags; ++i) {
-    int32_t tLen = getToStringLength(pTagValue, pTagsSchema[i].bytes, pTagsSchema[i].type);
-    if (len < tLen) {
-      len = tLen;
-    }
-
-    pTagValue += pTagsSchema[i].bytes;
-  }
-
-  return len;
-}
-
 static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
  SSqlRes *pRes = &pSql->res;

@@ -186,8 +110,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
    return 0;
  }

-  // the following is handle display tags value for meters created according to metric
-  char *pTagValue = tsGetTagsValue(pMeta);
+  // the following is handle display tags for table created according to super table
  for (int32_t i = numOfRows; i < totalNumOfRows; ++i) {
    // field name
    TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
@@ -219,8 +142,6 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
    char *target = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i;
    const char *src = "TAG";
    STR_WITH_MAXSIZE_TO_VARSTR(target, src, pField->bytes);
-
-    pTagValue += pSchema[i].bytes;
  }

  return 0;
@@ -241,7 +162,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  
  SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
-      (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE, (TSDB_COL_NAME_LEN - 1), false);
+      (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE, -1000, (TSDB_COL_NAME_LEN - 1), false);
  
  rowLen += ((TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE);

@@ -251,7 +172,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
-      typeColLength, false);
+      -1000, typeColLength, false);
  
  rowLen += typeColLength + VARSTR_HEADER_SIZE;

@@ -261,7 +182,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
-      sizeof(int32_t), false);
+      -1000, sizeof(int32_t), false);
  
  rowLen += sizeof(int32_t);

@@ -271,7 +192,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
-      noteColLength, false);
+      -1000, noteColLength, false);
  
  rowLen += noteColLength + VARSTR_HEADER_SIZE;
  return rowLen;
@@ -286,10 +207,10 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
  const int32_t TYPE_COLUMN_LENGTH = 16;
  const int32_t NOTE_COLUMN_MIN_LENGTH = 8;

-  int32_t noteFieldLen = tscMaxLengthOfTagsFields(pSql);
-  if (noteFieldLen == 0) {
-    noteFieldLen = NOTE_COLUMN_MIN_LENGTH;
-  }
+  int32_t noteFieldLen = NOTE_COLUMN_MIN_LENGTH;//tscMaxLengthOfTagsFields(pSql);
+//  if (noteFieldLen == 0) {
+//    noteFieldLen = NOTE_COLUMN_MIN_LENGTH;
+//  }

  int32_t rowLen = tscBuildTableSchemaResultFields(pSql, NUM_OF_DESC_TABLE_COLUMNS, TYPE_COLUMN_LENGTH, noteFieldLen);
  tscFieldInfoUpdateOffset(pQueryInfo);
@@ -486,8 +407,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
  } 

  SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
-      f.bytes, f.bytes - VARSTR_HEADER_SIZE, false);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);

  rowLen += f.bytes; 

@@ -501,7 +421,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const

  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, 
-      (int16_t)(ddlLen + VARSTR_HEADER_SIZE), ddlLen, false);
+      (int16_t)(ddlLen + VARSTR_HEADER_SIZE), -1000, ddlLen, false);

  rowLen += ddlLen + VARSTR_HEADER_SIZE;

@@ -698,7 +618,11 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
  for (int32_t i = 0; i < numOfRows; ++i) {
    uint8_t type = pSchema[i].type;
    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      int32_t bytes = pSchema[i].bytes - VARSTR_HEADER_SIZE;
+      if (type == TSDB_DATA_TYPE_NCHAR) {
+        bytes =  bytes/TSDB_NCHAR_SIZE;
+      }
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName, bytes);
    } else {
      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName); 
    }
@@ -721,7 +645,11 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
  for (int32_t i = 0; i < numOfRows; ++i) {
    uint8_t type = pSchema[i].type;
    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result),"%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      int32_t bytes = pSchema[i].bytes - VARSTR_HEADER_SIZE;
+      if (type == TSDB_DATA_TYPE_NCHAR) {
+        bytes =  bytes/TSDB_NCHAR_SIZE;
+      }
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result),"%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName, bytes);
    } else {
      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
    }
@@ -731,7 +659,11 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
  for (int32_t i = numOfRows; i < totalRows; i++) {
    uint8_t type = pSchema[i].type;
    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      int32_t bytes = pSchema[i].bytes - VARSTR_HEADER_SIZE;
+      if (type == TSDB_DATA_TYPE_NCHAR) {
+        bytes =  bytes/TSDB_NCHAR_SIZE;
+      }
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName, bytes);
    } else {
      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
    }

--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -13,14 +13,15 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

+#include "tscLocalMerge.h"
+#include "tscSubquery.h"
 #include "os.h"
+#include "qAst.h"
 #include "tlosertree.h"
+#include "tscLog.h"
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
-#include "tutil.h"
-#include "tscLog.h"
-#include "tscLocalMerge.h"

 typedef struct SCompareParam {
  SLocalDataSource **pLocalData;
@@ -29,6 +30,8 @@ typedef struct SCompareParam {
  int32_t            groupOrderType;
 } SCompareParam;

+static void doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize);
+
 int32_t treeComparator(const void *pLeft, const void *pRight, void *param) {
  int32_t pLeftIdx = *(int32_t *)pLeft;
  int32_t pRightIdx = *(int32_t *)pRight;
@@ -97,14 +100,14 @@ static void tscInitSqlContext(SSqlCmd *pCmd, SLocalReducer *pReducer, tOrderDesc
      pCtx->param[2].i64Key = pQueryInfo->order.order;
      pCtx->param[2].nType  = TSDB_DATA_TYPE_BIGINT;
      pCtx->param[1].i64Key = pQueryInfo->order.orderColId;
+    } else if (functionId == TSDB_FUNC_APERCT) {
+      pCtx->param[0].i64Key = pExpr->param[0].i64Key;
+      pCtx->param[0].nType  = pExpr->param[0].nType;
    }

-    SResultInfo *pResInfo = &pReducer->pResInfo[i];
-    pResInfo->bufLen = pExpr->interBytes;
-    pResInfo->interResultBuf = calloc(1, (size_t) pResInfo->bufLen);
-
-    pCtx->resultInfo = &pReducer->pResInfo[i];
-    pCtx->resultInfo->superTableQ = true;
+    pCtx->interBufBytes = pExpr->interBytes;
+    pCtx->resultInfo = calloc(1, pCtx->interBufBytes + sizeof(SResultRowCellInfo));
+    pCtx->stableQuery = true;
  }

  int16_t          n = 0;
@@ -132,28 +135,41 @@ static void tscInitSqlContext(SSqlCmd *pCmd, SLocalReducer *pReducer, tOrderDesc
 }

 static SFillColInfo* createFillColInfo(SQueryInfo* pQueryInfo) {
-  int32_t numOfCols = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfCols = (int32_t)tscNumOfFields(pQueryInfo);
  int32_t offset = 0;
  
  SFillColInfo* pFillCol = calloc(numOfCols, sizeof(SFillColInfo));
  for(int32_t i = 0; i < numOfCols; ++i) {
-    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
-    
-    pFillCol[i].col.bytes  = pExpr->resBytes;
-    pFillCol[i].col.type   = (int8_t)pExpr->resType;
-    pFillCol[i].col.colId  = pExpr->colInfo.colId;
-    pFillCol[i].flag       = pExpr->colInfo.flag;
-    pFillCol[i].col.offset = offset;
-    pFillCol[i].functionId = pExpr->functionId;
-    pFillCol[i].fillVal.i  = pQueryInfo->fillVal[i];
-    offset += pExpr->resBytes;
+    SInternalField* pIField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
+
+    if (pIField->pArithExprInfo == NULL) {
+      SSqlExpr* pExpr = pIField->pSqlExpr;
+
+      pFillCol[i].col.bytes  = pExpr->resBytes;
+      pFillCol[i].col.type   = (int8_t)pExpr->resType;
+      pFillCol[i].col.colId  = pExpr->colInfo.colId;
+      pFillCol[i].flag       = pExpr->colInfo.flag;
+      pFillCol[i].col.offset = offset;
+      pFillCol[i].functionId = pExpr->functionId;
+      pFillCol[i].fillVal.i  = pQueryInfo->fillVal[i];
+    } else {
+      pFillCol[i].col.bytes  = pIField->field.bytes;
+      pFillCol[i].col.type   = (int8_t)pIField->field.type;
+      pFillCol[i].col.colId  = -100;
+      pFillCol[i].flag       = TSDB_COL_NORMAL;
+      pFillCol[i].col.offset = offset;
+      pFillCol[i].functionId = -1;
+      pFillCol[i].fillVal.i  = pQueryInfo->fillVal[i];
+    }
+
+    offset += pFillCol[i].col.bytes;
  }
  
  return pFillCol;
 }

 void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                           SColumnModel *finalmodel, SSqlObj* pSql) {
+                           SColumnModel *finalmodel, SColumnModel *pFFModel, SSqlObj* pSql) {
  SSqlCmd* pCmd = &pSql->cmd;
  SSqlRes* pRes = &pSql->res;
  
@@ -227,7 +243,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
      if (ds == NULL) {
        tscError("%p failed to create merge structure", pSql);
        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-        taosTFree(pReducer);
+        tfree(pReducer);
        return;
      }
      
@@ -254,7 +270,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
      
      if (ds->filePage.num == 0) {  // no data in this flush, the index does not increase
        tscDebug("%p flush data is empty, ignore %d flush record", pSql, idx);
-        taosTFree(ds);
+        tfree(ds);
        continue;
      }
      
@@ -264,7 +280,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  
  // no data actually, no need to merge result.
  if (idx == 0) {
-    taosTFree(pReducer);
+    tfree(pReducer);
    return;
  }

@@ -272,7 +288,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd

  SCompareParam *param = malloc(sizeof(SCompareParam));
  if (param == NULL) {
-    taosTFree(pReducer);
+    tfree(pReducer);
    return;
  }

@@ -286,8 +302,8 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd

  pRes->code = tLoserTreeCreate(&pReducer->pLoserTree, pReducer->numOfBuffer, param, treeComparator);
  if (pReducer->pLoserTree == NULL || pRes->code != 0) {
-    taosTFree(param);
-    taosTFree(pReducer);
+    tfree(param);
+    tfree(pReducer);
    return;
  }

@@ -330,22 +346,19 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd

  if (pReducer->pTempBuffer == NULL || pReducer->discardData == NULL || pReducer->pResultBuf == NULL ||
      /*pReducer->pBufForInterpo == NULL || */pReducer->pFinalRes == NULL || pReducer->prevRowOfInput == NULL) {
-    taosTFree(pReducer->pTempBuffer);
-    taosTFree(pReducer->discardData);
-    taosTFree(pReducer->pResultBuf);
-    taosTFree(pReducer->pFinalRes);
-    taosTFree(pReducer->prevRowOfInput);
-    taosTFree(pReducer->pLoserTree);
-    taosTFree(param);
-    taosTFree(pReducer);
+    tfree(pReducer->pTempBuffer);
+    tfree(pReducer->discardData);
+    tfree(pReducer->pResultBuf);
+    tfree(pReducer->pFinalRes);
+    tfree(pReducer->prevRowOfInput);
+    tfree(pReducer->pLoserTree);
+    tfree(param);
+    tfree(pReducer);
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    return;
  }
  
-  size_t numOfCols = tscSqlExprNumOfExprs(pQueryInfo);
-  
  pReducer->pTempBuffer->num = 0;
-  pReducer->pResInfo = calloc(numOfCols, sizeof(SResultInfo));

  tscCreateResPointerInfo(pRes, pQueryInfo);
  tscInitSqlContext(pCmd, pReducer, pDesc);
@@ -373,8 +386,8 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  if (pQueryInfo->fillType != TSDB_FILL_NONE) {
    SFillColInfo* pFillCol = createFillColInfo(pQueryInfo);
    pReducer->pFillInfo = taosInitFillInfo(pQueryInfo->order.order, revisedSTime, pQueryInfo->groupbyExpr.numOfGroupCols,
-                                           4096, (int32_t)numOfCols, pQueryInfo->interval.sliding, pQueryInfo->interval.slidingUnit,
-                                           tinfo.precision, pQueryInfo->fillType, pFillCol);
+                                           4096, (int32_t)pQueryInfo->fieldsInfo.numOfOutput, pQueryInfo->interval.sliding, pQueryInfo->interval.slidingUnit,
+                                           tinfo.precision, pQueryInfo->fillType, pFillCol, pSql);
  }
 }

@@ -489,47 +502,41 @@ void tscDestroyLocalReducer(SSqlObj *pSql) {
      tscDebug("%p waiting for delete procedure, status: %d", pSql, status);
    }

-    pLocalReducer->pFillInfo = taosDestoryFillInfo(pLocalReducer->pFillInfo);
+    pLocalReducer->pFillInfo = taosDestroyFillInfo(pLocalReducer->pFillInfo);

    if (pLocalReducer->pCtx != NULL) {
-      for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
+      int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+      for (int32_t i = 0; i < numOfExprs; ++i) {
        SQLFunctionCtx *pCtx = &pLocalReducer->pCtx[i];

        tVariantDestroy(&pCtx->tag);
+        tfree(pCtx->resultInfo);
+
        if (pCtx->tagInfo.pTagCtxList != NULL) {
-          taosTFree(pCtx->tagInfo.pTagCtxList);
+          tfree(pCtx->tagInfo.pTagCtxList);
        }
      }

-      taosTFree(pLocalReducer->pCtx);
+      tfree(pLocalReducer->pCtx);
    }

-    taosTFree(pLocalReducer->prevRowOfInput);
-
-    taosTFree(pLocalReducer->pTempBuffer);
-    taosTFree(pLocalReducer->pResultBuf);
+    tfree(pLocalReducer->prevRowOfInput);

-    if (pLocalReducer->pResInfo != NULL) {
-      size_t num = tscSqlExprNumOfExprs(pQueryInfo);
-      for (int32_t i = 0; i < num; ++i) {
-        taosTFree(pLocalReducer->pResInfo[i].interResultBuf);
-      }
-
-      taosTFree(pLocalReducer->pResInfo);
-    }
+    tfree(pLocalReducer->pTempBuffer);
+    tfree(pLocalReducer->pResultBuf);

    if (pLocalReducer->pLoserTree) {
-      taosTFree(pLocalReducer->pLoserTree->param);
-      taosTFree(pLocalReducer->pLoserTree);
+      tfree(pLocalReducer->pLoserTree->param);
+      tfree(pLocalReducer->pLoserTree);
    }

-    taosTFree(pLocalReducer->pFinalRes);
-    taosTFree(pLocalReducer->discardData);
+    tfree(pLocalReducer->pFinalRes);
+    tfree(pLocalReducer->discardData);

    tscLocalReducerEnvDestroy(pLocalReducer->pExtMemBuffer, pLocalReducer->pDesc, pLocalReducer->resColModel,
                              pLocalReducer->numOfVnode);
    for (int32_t i = 0; i < pLocalReducer->numOfBuffer; ++i) {
-      taosTFree(pLocalReducer->pLocalDataSrc[i]);
+      tfree(pLocalReducer->pLocalDataSrc[i]);
    }

    pLocalReducer->numOfBuffer = 0;
@@ -563,7 +570,8 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
  if (numOfGroupByCols > 0) {

    if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
-      int32_t startCols = pQueryInfo->fieldsInfo.numOfOutput - pQueryInfo->groupbyExpr.numOfGroupCols;
+      int32_t numOfInternalOutput = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+      int32_t startCols = numOfInternalOutput - pQueryInfo->groupbyExpr.numOfGroupCols;

      // the last "pQueryInfo->groupbyExpr.numOfGroupCols" columns are order-by columns
      for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
@@ -596,7 +604,7 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
  }

  *pOrderDesc = tOrderDesCreate(orderColIndexList, numOfGroupByCols, pModel, pQueryInfo->order.order);
-  taosTFree(orderColIndexList);
+  tfree(orderColIndexList);

  if (*pOrderDesc == NULL) {
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -682,6 +690,8 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr

    pSchema[i].bytes = pExpr->resBytes;
    pSchema[i].type = (int8_t)pExpr->resType;
+    tstrncpy(pSchema[i].name, pExpr->aliasName, tListLen(pSchema[i].name));
+
    rlen += pExpr->resBytes;
  }

@@ -707,7 +717,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr

  if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    taosTFree(pSchema);
+    tfree(pSchema);
    return pRes->code;
  }

@@ -744,8 +754,8 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
  }
  
  *pFinalModel = createColumnModel(pSchema, (int32_t)size, capacity);
-  taosTFree(pSchema);

+   tfree(pSchema);
  return TSDB_CODE_SUCCESS;
 }

@@ -764,7 +774,7 @@ void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDe
    pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
  }

-  taosTFree(pMemBuffer);
+  tfree(pMemBuffer);
 }

 /**
@@ -924,7 +934,7 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
  }

  while (1) {
-    int64_t newRows = taosGenerateDataBlock(pFillInfo, pResPages, pLocalReducer->resColModel->capacity);
+    int64_t newRows = taosFillResultDataBlock(pFillInfo, pResPages, pLocalReducer->resColModel->capacity);

    if (pQueryInfo->limit.offset < newRows) {
      newRows -= pQueryInfo->limit.offset;
@@ -953,7 +963,7 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
        }

        // all output in current group are completed
-        int32_t totalRemainRows = (int32_t)getFilledNumOfRes(pFillInfo, actualETime, pLocalReducer->resColModel->capacity);
+        int32_t totalRemainRows = (int32_t)getNumOfResWithFill(pFillInfo, actualETime, pLocalReducer->resColModel->capacity);
        if (totalRemainRows <= 0) {
          break;
        }
@@ -974,10 +984,11 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
      savePrevRecordAndSetupFillInfo(pLocalReducer, pQueryInfo, pFillInfo);
    }

+    int32_t offset = 0;
    for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
      TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
-      int16_t     offset = getColumnModelOffset(pLocalReducer->resColModel, i);
      memcpy(pRes->data + offset * pRes->numOfRows, pResPages[i]->data, (size_t)(pField->bytes * pRes->numOfRows));
+      offset += pField->bytes;
    }

    pRes->numOfRowsGroup += pRes->numOfRows;
@@ -986,10 +997,10 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO

  pBeforeFillData->num = 0;
  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    taosTFree(pResPages[i]);
+    tfree(pResPages[i]);
  }
  
-  taosTFree(pResPages);
+  tfree(pResPages);
 }

 static void savePreviousRow(SLocalReducer *pLocalReducer, tFilePage *tmpBuffer) {
@@ -1072,7 +1083,7 @@ static int64_t getNumOfResultLocal(SQueryInfo *pQueryInfo, SQLFunctionCtx *pCtx)
      continue;
    }

-    SResultInfo* pResInfo = GET_RES_INFO(&pCtx[j]);
+    SResultRowCellInfo* pResInfo = GET_RES_INFO(&pCtx[j]);
    if (maxOutput < pResInfo->numOfRes) {
      maxOutput = pResInfo->numOfRes;
    }
@@ -1230,6 +1241,10 @@ bool genFinalResults(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool noMoreCur

  tColModelCompact(pModel, pResBuf, pModel->capacity);

+  if (tscIsSecondStageQuery(pQueryInfo)) {
+    doArithmeticCalculate(pQueryInfo, pResBuf, pModel->rowSize, pLocalReducer->finalRowSize);
+  }
+
 #ifdef _DEBUG_VIEW
  printf("final result before interpo:\n");
 //  tColModelDisplay(pLocalReducer->resColModel, pLocalReducer->pBufForInterpo, pResBuf->num, pResBuf->num);
@@ -1253,10 +1268,11 @@ bool genFinalResults(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool noMoreCur
  return true;
 }

-void resetOutputBuf(SQueryInfo *pQueryInfo, SLocalReducer *pLocalReducer) {  // reset output buffer to the beginning
-  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    pLocalReducer->pCtx[i].aOutputBuf =
-        pLocalReducer->pResultBuf->data + tscFieldInfoGetOffset(pQueryInfo, i) * pLocalReducer->resColModel->capacity;
+void resetOutputBuf(SQueryInfo *pQueryInfo, SLocalReducer *pLocalReducer) {// reset output buffer to the beginning
+  size_t t = tscSqlExprNumOfExprs(pQueryInfo);
+  for (int32_t i = 0; i < t; ++i) {
+    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
+    pLocalReducer->pCtx[i].aOutputBuf = pLocalReducer->pResultBuf->data + pExpr->offset * pLocalReducer->resColModel->capacity;
  }

  memset(pLocalReducer->pResultBuf, 0, pLocalReducer->nResultBufSize + sizeof(tFilePage));
@@ -1301,7 +1317,7 @@ static bool doBuildFilledResultForGroup(SSqlObj *pSql) {
    int64_t etime = *(int64_t *)(pFinalDataBuf->data + TSDB_KEYSIZE * (pFillInfo->numOfRows - 1));

    // the first column must be the timestamp column
-    int32_t rows = (int32_t)getFilledNumOfRes(pFillInfo, etime, pLocalReducer->resColModel->capacity);
+    int32_t rows = (int32_t) getNumOfResWithFill(pFillInfo, etime, pLocalReducer->resColModel->capacity);
    if (rows > 0) {  // do fill gap
      doFillResult(pSql, pLocalReducer, false);
    }
@@ -1330,7 +1346,7 @@ static bool doHandleLastRemainData(SSqlObj *pSql) {
      ((pRes->numOfRowsGroup < pQueryInfo->limit.limit && pQueryInfo->limit.limit > 0) || (pQueryInfo->limit.limit < 0))) {
      int64_t etime = (pQueryInfo->order.order == TSDB_ORDER_ASC)? pQueryInfo->window.ekey : pQueryInfo->window.skey;

-      int32_t rows = (int32_t)getFilledNumOfRes(pFillInfo, etime, pLocalReducer->resColModel->capacity);
+      int32_t rows = (int32_t)getNumOfResWithFill(pFillInfo, etime, pLocalReducer->resColModel->capacity);
      if (rows > 0) {
        doFillResult(pSql, pLocalReducer, true);
      }
@@ -1501,8 +1517,7 @@ int32_t tscDoLocalMerge(SSqlObj *pSql) {
          if (pLocalReducer->discard && sameGroup) {
            pLocalReducer->hasUnprocessedRow = false;
            tmpBuffer->num = 0;
-          } else {
-            // current row does not belongs to the previous group, so it is not be handled yet.
+          } else { // current row does not belongs to the previous group, so it is not be handled yet.
            pLocalReducer->hasUnprocessedRow = true;
          }

@@ -1596,3 +1611,44 @@ void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen)
  pRes->pLocalReducer->pResultBuf->num = numOfRes;
  pRes->data = pRes->pLocalReducer->pResultBuf->data;
 }
+
+void doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize) {
+  char* pbuf = calloc(1, pOutput->num * rowSize);
+
+  size_t size = tscNumOfFields(pQueryInfo);
+  SArithmeticSupport arithSup = {0};
+
+  // todo refactor
+  arithSup.offset     = 0;
+  arithSup.numOfCols  = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  arithSup.exprList   = pQueryInfo->exprList;
+  arithSup.data       = calloc(arithSup.numOfCols, POINTER_BYTES);
+
+  for(int32_t k = 0; k < arithSup.numOfCols; ++k) {
+    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, k);
+    arithSup.data[k] = (pOutput->data + pOutput->num* pExpr->offset);
+  }
+
+  int32_t offset = 0;
+
+  for (int i = 0; i < size; ++i) {
+    SInternalField* pSup = TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
+    
+    // calculate the result from several other columns
+    if (pSup->pArithExprInfo != NULL) {
+      arithSup.pArithExpr = pSup->pArithExprInfo;
+      tExprTreeCalcTraverse(arithSup.pArithExpr->pExpr, (int32_t) pOutput->num, pbuf + pOutput->num*offset, &arithSup, TSDB_ORDER_ASC, getArithemicInputSrc);
+    } else {
+      SSqlExpr* pExpr = pSup->pSqlExpr;
+      memcpy(pbuf + pOutput->num * offset, pExpr->offset * pOutput->num + pOutput->data, pExpr->resBytes * pOutput->num);
+    }
+
+    offset += pSup->field.bytes;
+  }
+
+  assert(finalRowSize <= rowSize);
+  memcpy(pOutput->data, pbuf, pOutput->num * finalRowSize);
+
+  tfree(pbuf);
+  tfree(arithSup.data);
+}
\ No newline at end of file
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -702,7 +702,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **st
  }

  int32_t code = TSDB_CODE_TSC_INVALID_SQL;
-  char *  tmpTokenBuf = calloc(1, 4096);  // used for deleting Escape character: \\, \', \"
+  char *  tmpTokenBuf = calloc(1, 16*1024);  // used for deleting Escape character: \\, \', \"
  if (NULL == tmpTokenBuf) {
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
  }
@@ -1148,6 +1148,10 @@ int tsParseInsertSql(SSqlObj *pSql) {

      index = 0;
      sToken = tStrGetToken(str, &index, false, 0, NULL);
+      if (sToken.type != TK_STRING && sToken.type != TK_ID) {
+        code = tscInvalidSQLErrMsg(pCmd->payload, "file path is required following keyword FILE", sToken.z);
+        goto _error;
+      }
      str += index;
      if (sToken.n == 0) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "file path is required following keyword FILE", sToken.z);
@@ -1309,7 +1313,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
  if ((!pCmd->parseFinished) && (!initial)) {
    tscDebug("%p resume to parse sql: %s", pSql, pCmd->curSql);
  }
-  
+
  ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
  if (TSDB_CODE_SUCCESS != ret) {
    return ret;
@@ -1406,7 +1410,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
    assert(taos_errno(pSql) == code);

    taos_free_result(pSql);
-    taosTFree(pSupporter);
+    tfree(pSupporter);
    fclose(fp);

    pParentSql->res.code = code;
@@ -1445,7 +1449,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {

  char *tokenBuf = calloc(1, 4096);

-  while ((readLen = taosGetline(&line, &n, fp)) != -1) {
+  while ((readLen = tgetline(&line, &n, fp)) != -1) {
    if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
      line[--readLen] = 0;
    }
@@ -1470,7 +1474,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
    }
  }

-  taosTFree(tokenBuf);
+  tfree(tokenBuf);
  free(line);

  if (count > 0) {
@@ -1483,7 +1487,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {

  } else {
    taos_free_result(pSql);
-    taosTFree(pSupporter);
+    tfree(pSupporter);
    fclose(fp);

    pParentSql->fp = pParentSql->fetchFp;
@@ -1513,7 +1517,7 @@ void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql) {
    pSql->res.code = TAOS_SYSTEM_ERROR(errno);
    tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));

-    taosTFree(pSupporter)
+    tfree(pSupporter)
    tscQueueAsyncRes(pSql);

    return;

--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -222,7 +222,7 @@ void tscKillStream(STscObj *pObj, uint32_t killId) {
 }

 int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
-  SCMHeartBeatMsg *pHeartbeat = pMsg;
+  SHeartBeatMsg *pHeartbeat = pMsg;
  int allocedQueriesNum = pHeartbeat->numOfQueries;
  int allocedStreamsNum = pHeartbeat->numOfStreams;
  
@@ -277,7 +277,7 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
  }

  int32_t msgLen = pHeartbeat->numOfQueries * sizeof(SQueryDesc) + pHeartbeat->numOfStreams * sizeof(SStreamDesc) +
-                   sizeof(SCMHeartBeatMsg);
+                   sizeof(SHeartBeatMsg);
  pHeartbeat->connId = htonl(pObj->connId);
  pHeartbeat->numOfQueries = htonl(pHeartbeat->numOfQueries);
  pHeartbeat->numOfStreams = htonl(pHeartbeat->numOfStreams);

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscSchemaUtil.c
+++ b/src/client/src/tscSchemaUtil.c
@@ -118,7 +118,7 @@ SSchema* tscGetTableColumnSchema(const STableMeta* pTableMeta, int32_t colIndex)
 }

 // TODO for large number of columns, employ the binary search method
-SSchema* tscGetTableColumnSchemaById(STableMeta* pTableMeta, int16_t colId) {
+SSchema* tscGetColumnSchemaById(STableMeta* pTableMeta, int16_t colId) {
  STableComInfo tinfo = tscGetTableInfo(pTableMeta);

  for(int32_t i = 0; i < tinfo.numOfColumns + tinfo.numOfTags; ++i) {
@@ -130,17 +130,7 @@ SSchema* tscGetTableColumnSchemaById(STableMeta* pTableMeta, int16_t colId) {
  return NULL;
 }

-struct SSchema tscGetTbnameColumnSchema() {
-  struct SSchema s = {
-      .colId = TSDB_TBNAME_COLUMN_INDEX,
-      .type  = TSDB_DATA_TYPE_BINARY,
-      .bytes = TSDB_TABLE_NAME_LEN
-  };
-  
-  strcpy(s.name, TSQL_TBNAME_L);
-  return s;
-}
-static void tscInitCorVgroupInfo(SCMCorVgroupInfo *corVgroupInfo, SCMVgroupInfo *vgroupInfo) {
+static void tscInitCorVgroupInfo(SCorVgroupInfo *corVgroupInfo, SVgroupInfo *vgroupInfo) {
  corVgroupInfo->version = 0;
  corVgroupInfo->inUse = 0;
  corVgroupInfo->numOfEps = vgroupInfo->numOfEps;
@@ -166,7 +156,7 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
  pTableMeta->id.tid = pTableMetaMsg->tid;
  pTableMeta->id.uid = pTableMetaMsg->uid;

-  SCMVgroupInfo* pVgroupInfo = &pTableMeta->vgroupInfo;
+  SVgroupInfo* pVgroupInfo = &pTableMeta->vgroupInfo;
  pVgroupInfo->numOfEps = pTableMetaMsg->vgroup.numOfEps;
  pVgroupInfo->vgId = pTableMetaMsg->vgroup.vgId;

@@ -197,28 +187,6 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
  return pTableMeta;
 }

-/**
- * the TableMeta data format in memory is as follows:
- *
- * +--------------------+
- * |STableMeta Body data|  sizeof(STableMeta)
- * +--------------------+
- * |Schema data         |  numOfTotalColumns * sizeof(SSchema)
- * +--------------------+
- * |Tags data           |  tag_col_1.bytes + tag_col_2.bytes + ....
- * +--------------------+
- *
- * @param pTableMeta
- * @return
- */
-char* tsGetTagsValue(STableMeta* pTableMeta) {
-  int32_t offset = 0;
-//  int32_t  numOfTotalCols = pTableMeta->numOfColumns + pTableMeta->numOfTags;
-//  uint32_t offset = sizeof(STableMeta) + numOfTotalCols * sizeof(SSchema);
-
-  return ((char*)pTableMeta + offset);
-}
-
 // todo refactor
 UNUSED_FUNC static FORCE_INLINE char* skipSegments(char* input, char delim, int32_t num) {
  for (int32_t i = 0; i < num; ++i) {

--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -28,7 +28,6 @@
 #include "tutil.h"
 #include "ttimer.h"
 #include "tscProfile.h"
-#include "ttimer.h"

 static bool validImpl(const char* str, size_t maxsize) {
  if (str == NULL) {
@@ -161,6 +160,7 @@ static SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pa
  registerSqlObj(pSql);
  tsInsertHeadSize = sizeof(SMsgDesc) + sizeof(SSubmitMsg);

+  pObj->rid = taosAddRef(tscRefId, pObj);
  return pSql;
 }

@@ -278,9 +278,9 @@ void taos_close(TAOS *taos) {

  SSqlObj* pHb = pObj->pHb;
  if (pHb != NULL && atomic_val_compare_exchange_ptr(&pObj->pHb, pHb, 0) == pHb) {
-    if (pHb->pRpcCtx != NULL) {  // wait for rsp from dnode
-      rpcCancelRequest(pHb->pRpcCtx);
-      pHb->pRpcCtx = NULL;
+    if (pHb->rpcRid > 0) {  // wait for rsp from dnode
+      rpcCancelRequest(pHb->rpcRid);
+      pHb->rpcRid = -1;
    }

    tscDebug("%p HB is freed", pHb);
@@ -296,7 +296,8 @@ void taos_close(TAOS *taos) {
  }

  tscDebug("%p all sqlObj are freed, free tscObj and close dnodeConn:%p", pObj, pObj->pDnodeConn);
-  tscCloseTscObj(pObj);
+
+  taosRemoveRef(tscRefId, pObj->rid);
 }

 void waitForQueryRsp(void *param, TAOS_RES *tres, int code) {
@@ -480,7 +481,7 @@ int taos_fetch_block_impl(TAOS_RES *res, TAOS_ROW *rows) {

  assert(0);
  for (int i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i);
+    tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i, 0);
  }

  *rows = pRes->tsrow;
@@ -564,7 +565,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
    pRes->rspType = 0;

    pSql->subState.numOfSub = 0;
-    taosTFree(pSql->pSubs);
+    tfree(pSql->pSubs);

    assert(pSql->fp == NULL);

@@ -746,9 +747,9 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
    assert(pSubObj->self == (SSqlObj**) p);

    pSubObj->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
-    if (pSubObj->pRpcCtx != NULL) {
-      rpcCancelRequest(pSubObj->pRpcCtx);
-      pSubObj->pRpcCtx = NULL;
+    if (pSubObj->rpcRid > 0) {
+      rpcCancelRequest(pSubObj->rpcRid);
+      pSubObj->rpcRid = -1;
    }

    tscQueueAsyncRes(pSubObj);
@@ -773,7 +774,7 @@ void taos_stop_query(TAOS_RES *res) {
  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);

  if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
-    assert(pSql->pRpcCtx == NULL);
+    assert(pSql->rpcRid <= 0);
    tscKillSTableQuery(pSql);
  } else {
    if (pSql->cmd.command < TSDB_SQL_LOCAL) {
@@ -782,9 +783,9 @@ void taos_stop_query(TAOS_RES *res) {
       * reset and freed in the processMsgFromServer function, and causes the invalid
       * write problem for rpcCancelRequest.
       */
-      if (pSql->pRpcCtx != NULL) {
-        rpcCancelRequest(pSql->pRpcCtx);
-        pSql->pRpcCtx = NULL;
+      if (pSql->rpcRid > 0) {
+        rpcCancelRequest(pSql->rpcRid);
+        pSql->rpcRid = -1;
      }

      tscQueueAsyncRes(pSql);
@@ -892,7 +893,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  if (sqlLen > tsMaxSQLStringLen) {
    tscError("%p sql too long", pSql);
    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
-    taosTFree(pSql);
+    tfree(pSql);
    return pRes->code;
  }

@@ -901,7 +902,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    tscError("%p failed to malloc sql string buffer", pSql);
    tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(pSql), pObj);
-    taosTFree(pSql);
+    tfree(pSql);
    return pRes->code;
  }


--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -273,7 +273,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf

    taosCacheRelease(tscMetaCache, (void**)&(pTableMetaInfo->pTableMeta), false);
    tscFreeSqlResult(pSql);
-    taosTFree(pSql->pSubs);
+    tfree(pSql->pSubs);
    pSql->subState.numOfSub = 0;
    pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
    tscSetNextLaunchTimer(pStream, pSql);
@@ -617,6 +617,6 @@ void taos_close_stream(TAOS_STREAM *handle) {
    pStream->pSql = NULL;

    taos_free_result(pSql);
-    taosTFree(pStream);
+    tfree(pStream);
  }
 }
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -44,6 +44,7 @@ extern int32_t  tsMaxShellConns;
 extern int32_t  tsShellActivityTimer;
 extern uint32_t tsMaxTmrCtrl;
 extern float    tsNumOfThreadsPerCore;
+extern int32_t  tsNumOfCommitThreads;
 extern float    tsRatioOfQueryThreads;  // todo remove it
 extern int8_t   tsDaylight;
 extern char     tsTimezone[];
@@ -51,6 +52,7 @@ extern char     tsLocale[];
 extern char     tsCharset[];            // default encode string
 extern int32_t  tsEnableCoreFile;
 extern int32_t  tsCompressMsgSize;
+extern char     tsTempDir[];

 //query buffer management
 extern int32_t  tsQueryBufferSize;      // maximum allowed usage buffer for each data node during query processing
@@ -87,6 +89,7 @@ extern int16_t tsWAL;
 extern int32_t tsFsyncPeriod;
 extern int32_t tsReplications;
 extern int32_t tsQuorum;
+extern int32_t tsUpdate;

 // balance
 extern int32_t tsEnableBalance;

--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -35,6 +35,6 @@ bool tscValidateTableNameLength(size_t len);

 SColumnFilterInfo* tscFilterInfoClone(const SColumnFilterInfo* src, int32_t numOfFilters);

-// int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, int64_t intervalTime, char timeUnit, int16_t precision);
+SSchema tscGetTbnameColumnSchema();

 #endif  // TDENGINE_NAME_H
--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -188,3 +188,14 @@ void extractTableNameFromToken(SStrToken* pToken, SStrToken* pTable) {
    pToken->z = r;
  }
 }
+
+SSchema tscGetTbnameColumnSchema() {
+  struct SSchema s = {
+      .colId = TSDB_TBNAME_COLUMN_INDEX,
+      .type  = TSDB_DATA_TYPE_BINARY,
+      .bytes = TSDB_TABLE_NAME_LEN
+  };
+
+  strcpy(s.name, TSQL_TBNAME_L);
+  return s;
+}
\ No newline at end of file
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -108,7 +108,7 @@ void tVariantCreateFromBinary(tVariant *pVar, const char *pz, size_t len, uint32
      break;
    }
    case TSDB_DATA_TYPE_BINARY: {  // todo refactor, extract a method
-      pVar->pz = calloc(len, sizeof(char));
+      pVar->pz = calloc(len + 1, sizeof(char));
      memcpy(pVar->pz, pz, len);
      pVar->nLen = (int32_t)len;
      break;
@@ -125,7 +125,7 @@ void tVariantDestroy(tVariant *pVar) {
  if (pVar == NULL) return;
  
  if (pVar->nType == TSDB_DATA_TYPE_BINARY || pVar->nType == TSDB_DATA_TYPE_NCHAR) {
-    taosTFree(pVar->pz);
+    tfree(pVar->pz);
    pVar->nLen = 0;
  }


--- a/src/connector/C#/TDengineDriver.cs
+++ b/src/connector/C#/TDengineDriver.cs
--- a/go @ 050667e5
+++ b/go @ 050667e5
-Subproject commit 8d7bf743852897110cbdcc7c4322cd7a74d4167b
+Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f
--- a/hivemq-tdengine-extension @ b62a26ec
+++ b/hivemq-tdengine-extension @ b62a26ec
+Subproject commit b62a26ecc164a310104df57691691b237e091c89
--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDatabaseMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDatabaseMetaData.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
--- a/src/cq/test/cqtest.c
+++ b/src/cq/test/cqtest.c
--- a/src/dnode/inc/dnodeCfg.h
+++ b/src/dnode/inc/dnodeCfg.h
--- a/src/dnode/inc/dnodeEps.h
+++ b/src/dnode/inc/dnodeEps.h
--- a/src/dnode/inc/dnodeMInfos.h
+++ b/src/dnode/inc/dnodeMInfos.h
--- a/src/dnode/inc/dnodeMPeer.h
+++ b/src/dnode/inc/dnodeMPeer.h
--- a/src/dnode/inc/dnodeMRead.h
+++ b/src/dnode/inc/dnodeMRead.h
--- a/src/dnode/inc/dnodeMWrite.h
+++ b/src/dnode/inc/dnodeMWrite.h
--- a/src/dnode/inc/dnodeMgmt.h
+++ b/src/dnode/inc/dnodeMgmt.h
--- a/src/dnode/inc/dnodeVRead.h
+++ b/src/dnode/inc/dnodeVRead.h
--- a/src/dnode/inc/dnodeVWrite.h
+++ b/src/dnode/inc/dnodeVWrite.h
--- a/src/dnode/src/dnodeCfg.c
+++ b/src/dnode/src/dnodeCfg.c
--- a/src/dnode/src/dnodeCheck.c
+++ b/src/dnode/src/dnodeCheck.c
--- a/src/dnode/src/dnodeEps.c
+++ b/src/dnode/src/dnodeEps.c
--- a/src/dnode/src/dnodeMInfos.c
+++ b/src/dnode/src/dnodeMInfos.c
--- a/src/dnode/src/dnodeMPeer.c
+++ b/src/dnode/src/dnodeMPeer.c
--- a/src/dnode/src/dnodeMRead.c
+++ b/src/dnode/src/dnodeMRead.c
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
--- a/src/dnode/src/dnodeMgmt.c
+++ b/src/dnode/src/dnodeMgmt.c
--- a/src/dnode/src/dnodeModule.c
+++ b/src/dnode/src/dnodeModule.c
--- a/src/dnode/src/dnodePeer.c
+++ b/src/dnode/src/dnodePeer.c
--- a/src/dnode/src/dnodeShell.c
+++ b/src/dnode/src/dnodeShell.c
--- a/src/dnode/src/dnodeTelemetry.c
+++ b/src/dnode/src/dnodeTelemetry.c
--- a/src/dnode/src/dnodeVRead.c
+++ b/src/dnode/src/dnodeVRead.c
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
--- a/src/inc/dnode.h
+++ b/src/inc/dnode.h
--- a/src/inc/mnode.h
+++ b/src/inc/mnode.h
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
--- a/src/inc/tcq.h
+++ b/src/inc/tcq.h
--- a/src/inc/trpc.h
+++ b/src/inc/trpc.h
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
--- a/src/inc/tsync.h
+++ b/src/inc/tsync.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
--- a/src/inc/twal.h
+++ b/src/inc/twal.h
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
--- a/src/kit/CMakeLists.txt
+++ b/src/kit/CMakeLists.txt
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/CMakeLists.txt
+++ b/src/kit/taosdump/CMakeLists.txt
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/kit/taosdump/taosdump.sh
+++ b/src/kit/taosdump/taosdump.sh
--- a/src/mnode/inc/mnodeDef.h
+++ b/src/mnode/inc/mnodeDef.h
--- a/src/mnode/inc/mnodeProfile.h
+++ b/src/mnode/inc/mnodeProfile.h
--- a/src/mnode/inc/mnodeTable.h
+++ b/src/mnode/inc/mnodeTable.h
--- a/src/mnode/inc/mnodeVgroup.h
+++ b/src/mnode/inc/mnodeVgroup.h
--- a/src/mnode/src/mnodeAcct.c
+++ b/src/mnode/src/mnodeAcct.c
--- a/src/mnode/src/mnodeCluster.c
+++ b/src/mnode/src/mnodeCluster.c
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
--- a/src/mnode/src/mnodeInt.c
+++ b/src/mnode/src/mnodeInt.c
--- a/src/mnode/src/mnodeMain.c
+++ b/src/mnode/src/mnodeMain.c
--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
--- a/src/mnode/src/mnodePeer.c
+++ b/src/mnode/src/mnodePeer.c
--- a/src/mnode/src/mnodeProfile.c
+++ b/src/mnode/src/mnodeProfile.c
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/mnode/src/mnodeUser.c
+++ b/src/mnode/src/mnodeUser.c
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
--- a/src/os/inc/osDarwin.h
+++ b/src/os/inc/osDarwin.h
--- a/src/os/inc/osFile.h
+++ b/src/os/inc/osFile.h
--- a/src/os/inc/osMemory.h
+++ b/src/os/inc/osMemory.h
--- a/src/os/inc/osSocket.h
+++ b/src/os/inc/osSocket.h
--- a/src/os/inc/osWindows.h
+++ b/src/os/inc/osWindows.h
--- a/src/os/src/darwin/darwinFile.c
+++ b/src/os/src/darwin/darwinFile.c
--- a/src/os/src/detail/osFail.c
+++ b/src/os/src/detail/osFail.c
--- a/src/os/src/detail/osFile.c
+++ b/src/os/src/detail/osFile.c
--- a/src/os/src/detail/osMemory.c
+++ b/src/os/src/detail/osMemory.c
--- a/src/os/src/detail/osSocket.c
+++ b/src/os/src/detail/osSocket.c
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
--- a/src/os/src/detail/osTimer.c
+++ b/src/os/src/detail/osTimer.c
--- a/src/os/src/windows/wAtomic.c
+++ b/src/os/src/windows/wAtomic.c
--- a/src/os/src/windows/wEnv.c
+++ b/src/os/src/windows/wEnv.c
--- a/src/os/src/windows/wFile.c
+++ b/src/os/src/windows/wFile.c
--- a/src/os/src/windows/wSocket.c
+++ b/src/os/src/windows/wSocket.c
--- a/src/plugins/http/inc/httpQueue.h
+++ b/src/plugins/http/inc/httpQueue.h
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
--- a/src/plugins/http/src/httpQueue.c
+++ b/src/plugins/http/src/httpQueue.c
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
--- a/src/plugins/http/src/httpSystem.c
+++ b/src/plugins/http/src/httpSystem.c
--- a/src/plugins/monitor/src/monitorMain.c
+++ b/src/plugins/monitor/src/monitorMain.c
--- a/src/query/inc/qAst.h
+++ b/src/query/inc/qAst.h
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
--- a/src/query/inc/qFill.h
+++ b/src/query/inc/qFill.h
--- a/src/query/inc/qHistogram.h
+++ b/src/query/inc/qHistogram.h
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
--- a/src/query/inc/qTsbuf.h
+++ b/src/query/inc/qTsbuf.h
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/inc/tsqlfunction.h
+++ b/src/query/inc/tsqlfunction.h
--- a/src/query/src/qAst.c
+++ b/src/query/src/qAst.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qHistogram.c
+++ b/src/query/src/qHistogram.c
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
--- a/src/query/src/qResultbuf.c
+++ b/src/query/src/qResultbuf.c
--- a/src/query/src/qTokenizer.c
+++ b/src/query/src/qTokenizer.c
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/query/tests/tsBufTest.cpp
+++ b/src/query/tests/tsBufTest.cpp
--- a/src/rpc/src/rpcCache.c
+++ b/src/rpc/src/rpcCache.c
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
--- a/src/rpc/src/rpcTcp.c
+++ b/src/rpc/src/rpcTcp.c
--- a/src/rpc/src/rpcUdp.c
+++ b/src/rpc/src/rpcUdp.c
--- a/src/rpc/test/rclient.c
+++ b/src/rpc/test/rclient.c
--- a/src/sync/inc/syncInt.h
+++ b/src/sync/inc/syncInt.h
--- a/src/sync/inc/taosTcpPool.h
+++ b/src/sync/inc/taosTcpPool.h
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
--- a/src/sync/src/syncRetrieve.c
+++ b/src/sync/src/syncRetrieve.c
--- a/src/sync/src/taosTcpPool.c
+++ b/src/sync/src/taosTcpPool.c
--- a/src/sync/src/tarbitrator.c
+++ b/src/sync/src/tarbitrator.c
--- a/src/sync/test/syncClient.c
+++ b/src/sync/test/syncClient.c
--- a/src/sync/test/syncServer.c
+++ b/src/sync/test/syncServer.c
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
--- a/src/tsdb/src/tsdbBuffer.c
+++ b/src/tsdb/src/tsdbBuffer.c
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
--- a/src/tsdb/src/tsdbCommitQueue.c
+++ b/src/tsdb/src/tsdbCommitQueue.c
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/tsdb/tests/tsdbTests.cpp
+++ b/src/tsdb/tests/tsdbTests.cpp
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
--- a/src/util/inc/tarray.h
+++ b/src/util/inc/tarray.h
--- a/src/util/inc/tfile.h
+++ b/src/util/inc/tfile.h
--- a/src/util/inc/tnettest.h
+++ b/src/util/inc/tnettest.h
--- a/src/util/inc/tqueue.h
+++ b/src/util/inc/tqueue.h
--- a/src/util/inc/tref.h
+++ b/src/util/inc/tref.h
--- a/src/util/inc/tskiplist.h
+++ b/src/util/inc/tskiplist.h
--- a/src/util/inc/tsocket.h
+++ b/src/util/inc/tsocket.h
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
--- a/src/util/src/talgo.c
+++ b/src/util/src/talgo.c
--- a/src/util/src/tarray.c
+++ b/src/util/src/tarray.c
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
--- a/src/util/src/tconfig.c
+++ b/src/util/src/tconfig.c
--- a/src/util/src/tfile.c
+++ b/src/util/src/tfile.c
--- a/src/util/src/tkvstore.c
+++ b/src/util/src/tkvstore.c
--- a/src/util/src/tlog.c
+++ b/src/util/src/tlog.c
--- a/src/util/src/tmempool.c
+++ b/src/util/src/tmempool.c
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
--- a/src/util/src/tnote.c
+++ b/src/util/src/tnote.c
--- a/src/util/src/tref.c
+++ b/src/util/src/tref.c
--- a/src/util/src/tskiplist.c
+++ b/src/util/src/tskiplist.c
--- a/src/util/src/tsocket.c
+++ b/src/util/src/tsocket.c
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
--- a/src/util/tests/CMakeLists.txt
+++ b/src/util/tests/CMakeLists.txt
--- a/src/util/tests/skiplistTest.cpp
+++ b/src/util/tests/skiplistTest.cpp
--- a/src/util/tests/trefTest.c
+++ b/src/util/tests/trefTest.c
--- a/src/vnode/inc/vnodeCfg.h
+++ b/src/vnode/inc/vnodeCfg.h
--- a/src/vnode/inc/vnodeInt.h
+++ b/src/vnode/inc/vnodeInt.h
--- a/src/vnode/inc/vnodeVersion.h
+++ b/src/vnode/inc/vnodeVersion.h
--- a/src/vnode/src/vnodeCfg.c
+++ b/src/vnode/src/vnodeCfg.c
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
--- a/src/vnode/src/vnodeVersion.c
+++ b/src/vnode/src/vnodeVersion.c
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/src/wal/inc/walInt.h
+++ b/src/wal/inc/walInt.h
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
--- a/src/wal/src/walMgmt.c
+++ b/src/wal/src/walMgmt.c
--- a/src/wal/src/walUtil.c
+++ b/src/wal/src/walUtil.c
--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
--- a/src/wal/test/waltest.c
+++ b/src/wal/test/waltest.c
--- a/tests/examples/JDBC/JDBCDemo/README-jdbc-windows.md
+++ b/tests/examples/JDBC/JDBCDemo/README-jdbc-windows.md
--- a/tests/examples/JDBC/connectionPools/README-cn.md
+++ b/tests/examples/JDBC/connectionPools/README-cn.md
--- a/tests/examples/JDBC/connectionPools/pom.xml
+++ b/tests/examples/JDBC/connectionPools/pom.xml
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/ConnectionPoolDemo.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/ConnectionPoolDemo.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/common/InsertTask.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/common/InsertTask.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/C3p0Builder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/C3p0Builder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DbcpBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DbcpBuilder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DruidPoolBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DruidPoolBuilder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/HikariCpBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/HikariCpBuilder.java
--- a/tests/examples/JDBC/connectionPools/src/main/resources/log4j.properties
+++ b/tests/examples/JDBC/connectionPools/src/main/resources/log4j.properties
--- a/tests/examples/JDBC/mybatisplus-demo/.gitignore
+++ b/tests/examples/JDBC/mybatisplus-demo/.gitignore
--- a/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/MavenWrapperDownloader.java
+++ b/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/MavenWrapperDownloader.java
--- a/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/maven-wrapper.jar
+++ b/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/maven-wrapper.jar
--- a/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/maven-wrapper.properties
+++ b/tests/examples/JDBC/mybatisplus-demo/.mvn/wrapper/maven-wrapper.properties
--- a/tests/examples/JDBC/mybatisplus-demo/mvnw
+++ b/tests/examples/JDBC/mybatisplus-demo/mvnw
--- a/tests/examples/JDBC/mybatisplus-demo/mvnw.cmd
+++ b/tests/examples/JDBC/mybatisplus-demo/mvnw.cmd
--- a/tests/examples/JDBC/mybatisplus-demo/pom.xml
+++ b/tests/examples/JDBC/mybatisplus-demo/pom.xml
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/MybatisplusDemoApplication.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/MybatisplusDemoApplication.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/config/MybatisPlusConfig.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/config/MybatisPlusConfig.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Temperature.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Temperature.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Weather.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Weather.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/TemperatureMapper.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/TemperatureMapper.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/WeatherMapper.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/WeatherMapper.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
--- a/tests/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/TemperatureMapperTest.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/TemperatureMapperTest.java
--- a/tests/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/WeatherMapperTest.java
+++ b/tests/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/WeatherMapperTest.java
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
--- a/tests/examples/c/asyncdemo.c
+++ b/tests/examples/c/asyncdemo.c
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
--- a/tests/examples/go/taosdemo.go
+++ b/tests/examples/go/taosdemo.go
--- a/tests/examples/nodejs/README-win.md
+++ b/tests/examples/nodejs/README-win.md
--- a/tests/examples/nodejs/nodejsChecker.js
+++ b/tests/examples/nodejs/nodejsChecker.js
--- a/rust @ f2ffd305
+++ b/rust @ f2ffd305
--- a/tests/examples/rust/.gitignore
+++ b/tests/examples/rust/.gitignore
--- a/tests/examples/rust/Cargo.toml
+++ b/tests/examples/rust/Cargo.toml
--- a/tests/examples/rust/README.md
+++ b/tests/examples/rust/README.md
--- a/tests/examples/rust/build.rs
+++ b/tests/examples/rust/build.rs
--- a/tests/examples/rust/examples/demo.rs
+++ b/tests/examples/rust/examples/demo.rs
--- a/tests/examples/rust/examples/subscribe.rs
+++ b/tests/examples/rust/examples/subscribe.rs
--- a/tests/examples/rust/src/bindings.rs
+++ b/tests/examples/rust/src/bindings.rs
--- a/tests/examples/rust/src/lib.rs
+++ b/tests/examples/rust/src/lib.rs
--- a/tests/examples/rust/src/subscriber.rs
+++ b/tests/examples/rust/src/subscriber.rs
--- a/tests/examples/rust/src/tdengine.rs
+++ b/tests/examples/rust/src/tdengine.rs
--- a/tests/examples/rust/src/utils.rs
+++ b/tests/examples/rust/src/utils.rs
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
--- a/tests/pytest/alter/db_update_options.py
+++ b/tests/pytest/alter/db_update_options.py
--- a/tests/pytest/concurrent_inquiry.py
+++ b/tests/pytest/concurrent_inquiry.py
--- a/tests/pytest/cq.py
+++ b/tests/pytest/cq.py
--- a/tests/pytest/crash_gen.sh
+++ b/tests/pytest/crash_gen.sh
--- a/tests/pytest/crash_gen/crash_gen.py
+++ b/tests/pytest/crash_gen/crash_gen.py
--- a/tests/pytest/crash_gen/db.py
+++ b/tests/pytest/crash_gen/db.py
--- a/tests/pytest/crash_gen/misc.py
+++ b/tests/pytest/crash_gen/misc.py
--- a/tests/pytest/crash_gen/service_manager.py
+++ b/tests/pytest/crash_gen/service_manager.py
--- a/tests/pytest/crash_gen_bootstrap.py
+++ b/tests/pytest/crash_gen_bootstrap.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/functions/function_arithmetic.py
+++ b/tests/pytest/functions/function_arithmetic.py
--- a/tests/pytest/functions/function_percentile.py
+++ b/tests/pytest/functions/function_percentile.py
--- a/tests/pytest/handle_crash_gen_val_log.sh
+++ b/tests/pytest/handle_crash_gen_val_log.sh
--- a/tests/pytest/insert/ningsiInsert.py
+++ b/tests/pytest/insert/ningsiInsert.py
--- a/tests/pytest/insert/restfulInsert.py
+++ b/tests/pytest/insert/restfulInsert.py
--- a/tests/pytest/query/bug1874.py
+++ b/tests/pytest/query/bug1874.py
--- a/tests/pytest/query/bug1875.py
+++ b/tests/pytest/query/bug1875.py
--- a/tests/pytest/query/bug1876.py
+++ b/tests/pytest/query/bug1876.py
--- a/tests/pytest/query/dataLossTest.py
+++ b/tests/pytest/query/dataLossTest.py
--- a/tests/pytest/query/kill_query.py
+++ b/tests/pytest/query/kill_query.py
--- a/tests/pytest/query/queryCountCSVData.py
+++ b/tests/pytest/query/queryCountCSVData.py
--- a/tests/pytest/query/queryInterval.py
+++ b/tests/pytest/query/queryInterval.py
--- a/tests/pytest/query/queryJoin.py
+++ b/tests/pytest/query/queryJoin.py
--- a/tests/pytest/query/queryLike.py
+++ b/tests/pytest/query/queryLike.py
--- a/tests/pytest/query/queryPerformance.py
+++ b/tests/pytest/query/queryPerformance.py
--- a/tests/pytest/query/query_performance.py
+++ b/tests/pytest/query/query_performance.py
--- a/tests/pytest/query/sliding.py
+++ b/tests/pytest/query/sliding.py
--- a/tests/pytest/table/create_sensitive.py
+++ b/tests/pytest/table/create_sensitive.py
--- a/tests/pytest/test_data/__init__.py
+++ b/tests/pytest/test_data/__init__.py
--- a/tests/pytest/test_data/disordered.csv
+++ b/tests/pytest/test_data/disordered.csv
--- a/tests/pytest/test_data/ordered.csv
+++ b/tests/pytest/test_data/ordered.csv
--- a/tests/pytest/tools/insert.json
+++ b/tests/pytest/tools/insert.json
--- a/tests/pytest/tools/lowa.py
+++ b/tests/pytest/tools/lowa.py
--- a/tests/pytest/update/allow_update-0.py
+++ b/tests/pytest/update/allow_update-0.py
--- a/tests/pytest/update/allow_update.py
+++ b/tests/pytest/update/allow_update.py
--- a/tests/pytest/update/append_commit_data-0.py
+++ b/tests/pytest/update/append_commit_data-0.py
--- a/tests/pytest/update/append_commit_data.py
+++ b/tests/pytest/update/append_commit_data.py
--- a/tests/pytest/update/append_commit_last-0.py
+++ b/tests/pytest/update/append_commit_last-0.py
--- a/tests/pytest/update/append_commit_last.py
+++ b/tests/pytest/update/append_commit_last.py
--- a/tests/pytest/update/merge_commit_data-0.py
+++ b/tests/pytest/update/merge_commit_data-0.py
--- a/tests/pytest/update/merge_commit_data.py
+++ b/tests/pytest/update/merge_commit_data.py
--- a/tests/pytest/update/merge_commit_data2.py
+++ b/tests/pytest/update/merge_commit_data2.py
--- a/tests/pytest/update/merge_commit_data2_update0.py
+++ b/tests/pytest/update/merge_commit_data2_update0.py
--- a/tests/pytest/update/merge_commit_last-0.py
+++ b/tests/pytest/update/merge_commit_last-0.py
--- a/tests/pytest/update/merge_commit_last.py
+++ b/tests/pytest/update/merge_commit_last.py
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
--- a/tests/pytest/wal/addOldWalTest.py
+++ b/tests/pytest/wal/addOldWalTest.py
--- a/tests/script/general/db/nosuchfile.sim
+++ b/tests/script/general/db/nosuchfile.sim
--- a/tests/script/general/http/restful_full.sim
+++ b/tests/script/general/http/restful_full.sim
--- a/tests/script/general/insert/basic.sim
+++ b/tests/script/general/insert/basic.sim
--- a/tests/script/general/parser/constCol.sim
+++ b/tests/script/general/parser/constCol.sim
--- a/tests/script/general/parser/fill.sim
+++ b/tests/script/general/parser/fill.sim
--- a/tests/script/general/parser/groupby.sim
+++ b/tests/script/general/parser/groupby.sim
--- a/tests/script/general/parser/join.sim
+++ b/tests/script/general/parser/join.sim
--- a/tests/script/general/parser/join_multivnode.sim
+++ b/tests/script/general/parser/join_multivnode.sim
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
--- a/tests/script/general/parser/sliding.sim
+++ b/tests/script/general/parser/sliding.sim
--- a/tests/script/general/parser/stream_on_sys.sim
+++ b/tests/script/general/parser/stream_on_sys.sim
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
--- a/tests/script/general/wal/kill.sim
+++ b/tests/script/general/wal/kill.sim
--- a/tests/script/general/wal/maxtables.sim
+++ b/tests/script/general/wal/maxtables.sim
--- a/tests/script/general/wal/sync.sim
+++ b/tests/script/general/wal/sync.sim
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/script/unique/dnode/data1.sim
+++ b/tests/script/unique/dnode/data1.sim
--- a/tests/script/unique/dnode/offline1.sim
+++ b/tests/script/unique/dnode/offline1.sim
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
--- a/tests/tsim/inc/sim.h
+++ b/tests/tsim/inc/sim.h
--- a/tests/tsim/inc/simParse.h
+++ b/tests/tsim/inc/simParse.h
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
--- a/tests/tsim/src/simMain.c
+++ b/tests/tsim/src/simMain.c
--- a/tests/tsim/src/simParse.c
+++ b/tests/tsim/src/simParse.c
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c