merge with master branch.

9af5765a · sangshuduo · b36f3e0b · 9a279550 · 9af5765a · 9af5765a
223 changed file
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -238,7 +238,7 @@ pipeline {
              sh '''
                cd ${WKC}/tests/examples/C#/taosdemo
                mcs -out:taosdemo *.cs > /dev/null 2>&1
-                echo '' |./taosdemo
+                echo '' |./taosdemo -c /etc/taos
              '''
              sh '''
                cd ${WKC}/tests/gotest
@@ -256,21 +256,19 @@ pipeline {
          steps {
            pre_test()
-            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                timeout(time: 60, unit: 'MINUTES'){
-                  sh '''
-                  cd ${WKC}/tests/pytest
-                  ./crash_gen.sh -a -p -t 4 -s 2000
-                  '''
-                }
-            }
            timeout(time: 60, unit: 'MINUTES'){
              sh '''
              cd ${WKC}/tests/pytest
-              rm -rf /var/lib/taos/*
+              ./crash_gen.sh -a -p -t 4 -s 2000
-              rm -rf /var/log/taos/*
-              ./handle_crash_gen_val_log.sh
              '''
+            }
+            timeout(time: 60, unit: 'MINUTES'){
+              // sh '''
+              // cd ${WKC}/tests/pytest
+              // rm -rf /var/lib/taos/*
+              // rm -rf /var/log/taos/*
+              // ./handle_crash_gen_val_log.sh
+              // '''
              sh '''
              cd ${WKC}/tests/pytest
              rm -rf /var/lib/taos/*

--- 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.1.7.1")
+  SET(TD_VER_NUMBER "2.2.0.1")
 ENDIF ()
 IF (DEFINED VERCOMPATIBLE)

--- a/TSZ @ 11c1060d
+++ b/TSZ @ 11c1060d
-Subproject commit ceda5bf9fcd7836509ac97dcc0056b3f1dd48cc5
+Subproject commit 11c1060d4f917dd799ae628b131db5d6a5ef6954
--- a/documentation20/cn/01.evaluation/docs.md
+++ b/documentation20/cn/01.evaluation/docs.md
@@ -2,18 +2,18 @@
 ## <a class="anchor" id="intro"></a>TDengine 简介
-TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
+TDengine 是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL 数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
-TDengine的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与Hadoop等典型的大数据平台相比，它具有如下鲜明的特点：
+TDengine 的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine 还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与 Hadoop 等典型的大数据平台相比，它具有如下鲜明的特点：
-* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
+* __10 倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少 2 万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
-* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
+* __硬件或云服务成本降至 1/5__：由于超强性能，计算资源不到通用大数据方案的 1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的 1/10。
-* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
+* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成 Kafka/Redis/HBase/Spark/HDFS 等软件，大幅降低应用开发和维护的复杂度成本。 
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, MATLAB随时进行。
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过 Shell, Python, R, MATLAB 随时进行。
-* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, 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相似，零学习成本。
+* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类标准 SQL，支持 RESTful，支持 Python/Java/C/C++/C#/Go/Node.js, 与 MySQL 相似，零学习成本。
-采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
+采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。
 ![TDengine技术生态图](page://images/eco_system.png)
 <center>图 1. TDengine技术生态图</center>
@@ -21,42 +21,47 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 ## <a class="anchor" id="scenes"></a>TDengine 总体适用场景
-作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
+作为一个 IOT 大数据平台，TDengine 的典型适用场景是在 IOT 范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如 CRM，ERP 等，不在本文讨论范围内。
 ### 数据源特点和需求
-从数据源角度，设计人员可以从下面几个角度分析TDengine在目标应用系统里面的适用性。
+从数据源角度，设计人员可以从下面几个角度分析 TDengine 在目标应用系统里面的适用性。
 |数据源特点和需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|总体数据量巨大|  |  | √ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
+|总体数据量巨大|  |  | √ | TDengine 在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
-|数据输入速度偶尔或者持续巨大|   |   | √ | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
+|数据输入速度偶尔或者持续巨大|   |   | √ | TDengine 的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
-|数据源数目巨大|   |   | √ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
+|数据源数目巨大|   |   | √ | TDengine 设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
 ### 系统架构要求
 |系统架构要求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求简单可靠的系统架构|  |  | √ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
+|要求简单可靠的系统架构|  |  | √ | TDengine 的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
-|要求容错和高可靠|  |  | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能。|
+|要求容错和高可靠|  |  | √ | TDengine 的集群功能，自动提供容错灾备等高可靠功能。|
-|标准化规范|  |  | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范。|
+|标准化规范|  |  | √ | TDengine 使用标准的SQL语言提供主要功能，遵守标准化规范。|
 ### 系统功能需求
 |系统功能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求完整的内置数据处理算法|  | √ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
+|要求完整的内置数据处理算法|  | √ |  | TDengine 的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
-|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能。|
+|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑 TDengine 和关系型数据系统配合实现系统功能。|
 ### 系统性能需求
 |系统性能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求较大的总体处理能力|  |  | √ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
+|要求较大的总体处理能力|  |  | √ | TDengine 的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
-|要求高速处理数据  | | | √ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
+|要求高速处理数据  | | | √ | TDengine 的专门为 IOT 优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
-|要求快速处理小粒度数据|  |  | √ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
+|要求快速处理小粒度数据|  |  | √ |这方面 TDengine 性能可以完全对标关系型和 NoSQL 型数据处理系统。|
 ### 系统维护需求
 |系统维护需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求系统可靠运行|  |  | √ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
+|要求系统可靠运行|  |  | √ | TDengine 的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
 |要求运维学习成本可控|  |  | √ |同上。|
-|要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
+|要求市场有大量人才储备| √ |  |  | TDengine 作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -102,6 +102,12 @@ elif  echo $osinfo | grep -qwi "centos" ; then
 elif echo $osinfo | grep -qwi "fedora" ; then
 #  echo "This is fedora system"
  os_type=2
+elif echo $osinfo | grep -qwi "Linx" ; then
+#  echo "This is Linx system"
+  os_type=1
+  service_mod=0
+  initd_mod=0
+  service_config_dir="/etc/systemd/system"
 else
  echo " osinfo: ${osinfo}"
  echo " This is an officially unverified linux system,"

--- a/packaging/tools/install_client.sh
+++ b/packaging/tools/install_client.sh
@@ -128,8 +128,12 @@ function install_lib() {
        ${csudo} ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
        ${csudo} ln -s ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
    fi
-    ${csudo} ldconfig
+    if [ "$osType" != "Darwin" ]; then
+        ${csudo} ldconfig
+    else
+        ${csudo} update_dyld_shared_cache
+    fi
 }
 function install_header() {

--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -19,35 +19,35 @@ else
 fi
 # Dynamic directory
-data_dir="/var/lib/taos"
 if [ "$osType" != "Darwin" ]; then
+    data_dir="/var/lib/taos"
    log_dir="/var/log/taos"
-else
-    log_dir=~/TDengine/log
-fi
-data_link_dir="/usr/local/taos/data"
-log_link_dir="/usr/local/taos/log"
-cfg_install_dir="/etc/taos"
+    cfg_install_dir="/etc/taos"
-if [ "$osType" != "Darwin" ]; then
    bin_link_dir="/usr/bin"
    lib_link_dir="/usr/lib"
    lib64_link_dir="/usr/lib64"
    inc_link_dir="/usr/include"
+    install_main_dir="/usr/local/taos"
+    bin_dir="/usr/local/taos/bin"
 else
+    data_dir="/usr/local/var/lib/taos"
+    log_dir="/usr/local/var/log/taos"
+    cfg_install_dir="/usr/local/etc/taos"
    bin_link_dir="/usr/local/bin"
    lib_link_dir="/usr/local/lib"
    inc_link_dir="/usr/local/include"
-fi
-#install main path
+    install_main_dir="/usr/local/Cellar/tdengine/${verNumber}"
-install_main_dir="/usr/local/taos"
-# old bin dir
+    bin_dir="/usr/local/Cellar/tdengine/${verNumber}/bin"
-bin_dir="/usr/local/taos/bin"
+fi
 service_config_dir="/etc/systemd/system"
@@ -59,12 +59,11 @@ GREEN_UNDERLINE='\033[4;32m'
 NC='\033[0m'
 csudo=""
-if command -v sudo > /dev/null; then
-    csudo="sudo"
-fi
 if [ "$osType" != "Darwin" ]; then
+    if command -v sudo > /dev/null; then
+    csudo="sudo"
+    fi
    initd_mod=0
    service_mod=2
    if pidof systemd &> /dev/null; then
@@ -137,17 +136,17 @@ function install_main_path() {
 function install_bin() {
    # Remove links
-    ${csudo} rm -f ${bin_link_dir}/taos         || :
+    ${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 || :
    if [ "$osType" != "Darwin" ]; then
-        ${csudo} rm -f ${bin_link_dir}/taosd    || :
+        ${csudo} rm -f ${bin_link_dir}/perfMonitor || :
-        ${csudo} rm -f ${bin_link_dir}/taosdemo || :
-        ${csudo} rm -f ${bin_link_dir}/taosdump || :
        ${csudo} rm -f ${bin_link_dir}/set_core || :
+        ${csudo} rm -f ${bin_link_dir}/rmtaos   || :
    fi
-    ${csudo} rm -f ${bin_link_dir}/rmtaos       || :
    ${csudo} cp -r ${binary_dir}/build/bin/* ${install_main_dir}/bin
    ${csudo} cp -r ${script_dir}/taosd-dump-cfg.gdb   ${install_main_dir}/bin
@@ -161,19 +160,18 @@ function install_bin() {
    ${csudo} chmod 0555 ${install_main_dir}/bin/*
    #Make link
-    [ -x ${install_main_dir}/bin/taos ]      && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos         || :
+    [ -x ${install_main_dir}/bin/taos ]      && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos    || :
+    [ -x ${install_main_dir}/bin/taosd ]     && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd   || :
+    [ -x ${install_main_dir}/bin/taosdump ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
+    [ -x ${install_main_dir}/bin/taosdemo ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
    if [ "$osType" != "Darwin" ]; then
-        [ -x ${install_main_dir}/bin/taosd ]     && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd   || :
+        [ -x ${install_main_dir}/bin/perfMonitor ]  && ${csudo} ln -s ${install_main_dir}/bin/perfMonitor ${bin_link_dir}/perfMonitor || :
-        [ -x ${install_main_dir}/bin/taosdump ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
-        [ -x ${install_main_dir}/bin/taosdemo ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
        [ -x ${install_main_dir}/set_core.sh ]  && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
    fi
    if [ "$osType" != "Darwin" ]; then
-        [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos  || :
+       [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos  || :
-    else
-        [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/rmtaos  || :
    fi
 }
@@ -220,7 +218,7 @@ function install_jemalloc() {
        fi
        if [ -d /etc/ld.so.conf.d ]; then
-            ${csudo} echo "/usr/local/lib" > /etc/ld.so.conf.d/jemalloc.conf
+            echo "/usr/local/lib" | ${csudo} tee /etc/ld.so.conf.d/jemalloc.conf
            ${csudo} ldconfig
        else
            echo "/etc/ld.so.conf.d not found!"
@@ -245,11 +243,12 @@ function install_lib() {
          ${csudo} ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so
        fi
    else
-        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
+        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
-        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.1.dylib ${lib_link_dir}/libtaos.1.dylib
+        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
        ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
    fi
    install_jemalloc
    if [ "$osType" != "Darwin" ]; then
@@ -259,10 +258,14 @@ function install_lib() {
 function install_header() {
-    ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h    || :
+    if [ "$osType" != "Darwin" ]; then
+        ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h    || :
+    fi
    ${csudo} cp -f ${source_dir}/src/inc/taos.h ${source_dir}/src/inc/taoserror.h ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*
-    ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
+    if [ "$osType" != "Darwin" ]; then
-    ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
+        ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
+        ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
+    fi
 }
 function install_config() {
@@ -270,23 +273,20 @@ function install_config() {
    if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
        ${csudo} mkdir -p ${cfg_install_dir}
-        [ -f ${script_dir}/../cfg/taos.cfg ] && ${csudo} cp ${script_dir}/../cfg/taos.cfg ${cfg_install_dir}
+        [ -f ${script_dir}/../cfg/taos.cfg ] &&
+        ${csudo} cp ${script_dir}/../cfg/taos.cfg ${cfg_install_dir}
        ${csudo} chmod 644 ${cfg_install_dir}/*
    fi
    ${csudo} cp -f ${script_dir}/../cfg/taos.cfg ${install_main_dir}/cfg/taos.cfg.org
-    ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+    if [ "$osType" != "Darwin" ]; then ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+    fi
 }
 function install_log() {
    ${csudo} rm -rf ${log_dir}  || :
+    ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
-    if [ "$osType" != "Darwin" ]; then
-        ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
-    else
-        mkdir -p ${log_dir} && chmod 777 ${log_dir}
-    fi
    ${csudo} ln -s ${log_dir} ${install_main_dir}/log
 }
@@ -307,7 +307,6 @@ function install_connector() {
        echo "WARNING: go connector not found, please check if want to use it!"
    fi
    ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector
    ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar || echo &> /dev/null
 }
@@ -487,24 +486,21 @@ function install_TDengine() {
    else
        echo -e "${GREEN}Start to install TDEngine Client ...${NC}"
    fi
    install_main_path
-    if [ "$osType" != "Darwin" ]; then
+    install_data
-        install_data
-    fi
    install_log
    install_header
    install_lib
    install_connector
    install_examples
    install_bin
    if [ "$osType" != "Darwin" ]; then
        install_service
    fi
    install_config
    if [ "$osType" != "Darwin" ]; then

--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
 name: tdengine
 base: core18
-version: '2.1.7.1'
+version: '2.2.0.1'
 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.1.7.1
+      - usr/lib/libtaos.so.2.2.0.1
      - usr/lib/libtaos.so.1
      - usr/lib/libtaos.so

--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -4,6 +4,8 @@ PROJECT(TDengine)
 INCLUDE_DIRECTORIES(inc)
 INCLUDE_DIRECTORIES(jni)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/zlib-1.2.11/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/plugins/http/inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 IF (TD_LINUX)

--- a/src/client/inc/tscGlobalmerge.h
+++ b/src/client/inc/tscGlobalmerge.h
@@ -58,6 +58,7 @@ typedef struct SRetrieveSupport {
  int32_t           subqueryIndex;     // index of current vnode in vnode list
  struct SSqlObj   *pParentSql;
  tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
+  uint32_t          localBufferSize;
  uint32_t          numOfRetry;        // record the number of retry times
 } SRetrieveSupport;

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -36,7 +36,7 @@ extern "C" {
  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_CHILD_TABLE))
 #define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo) \
-  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo) || UTIL_TABLE_IS_TMP_TABLE(metaInfo)))
+  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo)))
 #define UTIL_TABLE_IS_TMP_TABLE(metaInfo) \
  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_TEMP_TABLE))
@@ -55,7 +55,7 @@ typedef struct STidTags {
 #pragma pack(pop)
 typedef struct SJoinSupporter {
-  SSqlObj*        pObj;           // parent SqlObj
+  int64_t         pObj;           // parent SqlObj
  int32_t         subqueryIndex;  // index of sub query
  SInterval       interval;
  SLimitVal       limit;          // limit info
@@ -190,6 +190,7 @@ void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
 void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList);
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo);
 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize);
 void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
@@ -284,7 +285,7 @@ void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 SVgroupsInfo* tscVgroupInfoClone(SVgroupsInfo *pInfo);
 void* tscVgroupInfoClear(SVgroupsInfo *pInfo);
-void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src);
 /**
 * The create object function must be successful expect for the out of memory issue.
 *
@@ -360,6 +361,8 @@ SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg);
 void tscRemoveTableMetaBuf(STableMetaInfo* pTableMetaInfo, uint64_t id);
+char* cloneCurrentDBName(SSqlObj* pSql);
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -38,6 +38,11 @@ extern "C" {
 #include "qUtil.h"
 #include "tcmdtype.h"
+typedef enum {
+  TAOS_REQ_FROM_SHELL,
+  TAOS_REQ_FROM_HTTP
+} SReqOrigin;
 // forward declaration
 struct SSqlInfo;
@@ -307,6 +312,7 @@ typedef struct {
  char *         data;
  TAOS_ROW       tsrow;
  TAOS_ROW       urow;
+  bool           dataConverted;
  int32_t*       length;  // length for each field for current row
  char **        buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
  SColumnIndex*  pColumnIndex;
@@ -340,6 +346,7 @@ typedef struct STscObj {
  SRpcCorEpSet      *tscCorMgmtEpSet;
  pthread_mutex_t    mutex;
  int32_t            numOfObj; // number of sqlObj from this tscObj
+  SReqOrigin         from;
 } STscObj;
 typedef struct SSubqueryState {
@@ -375,6 +382,7 @@ typedef struct SSqlObj {
  SSubqueryState   subState;
  struct SSqlObj **pSubs;
+  struct SSqlObj  *rootObj;
  int64_t          metaRid;
  int64_t          svgroupRid;
@@ -439,7 +447,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo *pQueryInfo);
 void    tscRestoreFuncForSTableQuery(SQueryInfo *pQueryInfo);
 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock, bool convertNchar);
 void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlObj* pParent);
@@ -486,6 +494,7 @@ bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
 void tscSetBoundColumnInfo(SParsedDataColInfo *pColInfo, SSchema *pSchema, int32_t numOfCols);
 char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql);
 int32_t tscInvalidOperationMsg(char *msg, const char *additionalInfo, const char *sql);
 int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* sql);

--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -44,6 +44,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
  pSql->maxRetry  = TSDB_MAX_REPLICA;
  pSql->fp        = fp;
  pSql->fetchFp   = fp;
+  pSql->rootObj   = pSql;
  registerSqlObj(pSql);
@@ -60,17 +61,23 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
  tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
  pCmd->resColumnId = TSDB_RES_COL_ID;
+  taosAcquireRef(tscObjRef, pSql->self);
  int32_t code = tsParseSql(pSql, true);
-  if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return;
+  if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+    taosReleaseRef(tscObjRef, pSql->self);
+    return;
+  }
  if (code != TSDB_CODE_SUCCESS) {
    pSql->res.code = code;
    tscAsyncResultOnError(pSql);
+    taosReleaseRef(tscObjRef, pSql->self);
    return;
  }
  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
  executeQuery(pSql, pQueryInfo);
+  taosReleaseRef(tscObjRef, pSql->self);
 }
 // TODO return the correct error code to client in tscQueueAsyncError
@@ -168,6 +175,9 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
    } else {
      pRes->code = numOfRows;
    }
+    if (pRes->code == TSDB_CODE_SUCCESS) {
+      pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;           
+    }
    tscAsyncResultOnError(pSql);
    return;
@@ -358,15 +368,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      }
      if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT)) {  // stmt insert
-        STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-        code = tscGetTableMeta(pSql, pTableMetaInfo);
-        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-          taosReleaseRef(tscObjRef, pSql->self);
-          return;
-        } else {
-          assert(code == TSDB_CODE_SUCCESS);
-        }
        (*pSql->fp)(pSql->param, pSql, code);
      } else if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) { // file insert
        tscImportDataFromFile(pSql);

--- a/src/client/src/tscGlobalmerge.c
+++ b/src/client/src/tscGlobalmerge.c
@@ -35,6 +35,7 @@ typedef struct SCompareParam {
 static bool needToMerge(SSDataBlock* pBlock, SArray* columnIndexList, int32_t index, char **buf) {
  int32_t ret = 0;
  size_t  size = taosArrayGetSize(columnIndexList);
  if (size > 0) {
    ret = compare_aRv(pBlock, columnIndexList, (int32_t) size, index, buf, TSDB_ORDER_ASC);
@@ -564,9 +565,11 @@ static void savePrevOrderColumns(char** prevRow, SArray* pColumnList, SSDataBloc
  (*hasPrev) = true;
 }
+// tsdb_func_tag function only produce one row of result. Therefore, we need to copy the
+// output value to multiple rows
 static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput, int32_t numOfRows) {
  if (numOfRows <= 1) {
-    return ;
+    return;
  }
  for (int32_t k = 0; k < numOfOutput; ++k) {
@@ -574,12 +577,49 @@ static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput
      continue;
    }
-    int32_t inc = numOfRows - 1;  // tsdb_func_tag function only produce one row of result
+    char* src  = pCtx[k].pOutput;
-    char* src = pCtx[k].pOutput;
+    char* dst = pCtx[k].pOutput + pCtx[k].outputBytes;
-    for (int32_t i = 0; i < inc; ++i) {
+    // Let's start from the second row, as the first row has result value already.
-      pCtx[k].pOutput += pCtx[k].outputBytes;
+    for (int32_t i = 1; i < numOfRows; ++i) {
-      memcpy(pCtx[k].pOutput, src, (size_t)pCtx[k].outputBytes);
+      memcpy(dst, src, (size_t)pCtx[k].outputBytes);
+      dst += pCtx[k].outputBytes;
+    }
+  }
+}
+static void doMergeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr, int32_t rowIndex, char** pDataPtr) {
+  for (int32_t j = 0; j < numOfExpr; ++j) {
+    pCtx[j].pInput = pDataPtr[j] + pCtx[j].inputBytes * rowIndex;
+  }
+  for (int32_t j = 0; j < numOfExpr; ++j) {
+    int32_t functionId = pCtx[j].functionId;
+    if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
+      continue;
+    }
+    if (functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+      doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
+    } else {
+      aAggs[functionId].mergeFunc(&pCtx[j]);
+    }
+  }
+}
+static void doFinalizeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr) {
+  for(int32_t j = 0; j < numOfExpr; ++j) {
+    int32_t functionId = pCtx[j].functionId;
+    if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
+      continue;
+    }
+    if (functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+      doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+    } else {
+      aAggs[functionId].xFinalize(&pCtx[j]);
    }
  }
 }
@@ -588,52 +628,18 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
  SMultiwayMergeInfo* pInfo = pOperator->info;
  SQLFunctionCtx* pCtx = pInfo->binfo.pCtx;
-  char** add = calloc(pBlock->info.numOfCols, POINTER_BYTES);
+  char** addrPtr = calloc(pBlock->info.numOfCols, POINTER_BYTES);
  for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-    add[i] = pCtx[i].pInput;
+    addrPtr[i] = pCtx[i].pInput;
    pCtx[i].size = 1;
  }
  for(int32_t i = 0; i < pBlock->info.rows; ++i) {
    if (pInfo->hasPrev) {
      if (needToMerge(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
-        for (int32_t j = 0; j < numOfExpr; ++j) {
+        doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
-          pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
-        }
-        for (int32_t j = 0; j < numOfExpr; ++j) {
-          int32_t functionId = pCtx[j].functionId;
-          if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-            continue;
-          }
-          if (functionId < 0) {
-            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-            continue;
-          }
-          aAggs[functionId].mergeFunc(&pCtx[j]);
-        }
      } else {
-        for(int32_t j = 0; j < numOfExpr; ++j) {  // TODO refactor
+        doFinalizeResultImpl(pInfo, pCtx, numOfExpr);
-          int32_t functionId = pCtx[j].functionId;
-          if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-            continue;
-          }
-          if (functionId < 0) {
-            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-            continue;
-          }
-          aAggs[functionId].xFinalize(&pCtx[j]);
-        }
        int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput);
        setTagValueForMultipleRows(pCtx, pOperator->numOfOutput, numOfRows);
@@ -643,7 +649,7 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
        for(int32_t j = 0; j < numOfExpr; ++j) {
          pCtx[j].pOutput += (pCtx[j].outputBytes * numOfRows);
          if (pCtx[j].functionId == TSDB_FUNC_TOP || pCtx[j].functionId == TSDB_FUNC_BOTTOM) {
-            pCtx[j].ptsOutputBuf = pCtx[0].pOutput;
+            if(j>0) pCtx[j].ptsOutputBuf = pCtx[j-1].pOutput;
          }
        }
@@ -655,48 +661,10 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
          aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
        }
-        for (int32_t j = 0; j < numOfExpr; ++j) {
+        doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
-          pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
-        }
-        for (int32_t j = 0; j < numOfExpr; ++j) {
-          int32_t functionId = pCtx[j].functionId;
-          if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-            continue;
-          }
-          if (functionId < 0) {
-            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-            continue;
-          }
-          aAggs[functionId].mergeFunc(&pCtx[j]);
-        }
      }
    } else {
-      for (int32_t j = 0; j < numOfExpr; ++j) {
+      doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
-        pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
-      }
-      for (int32_t j = 0; j < numOfExpr; ++j) {
-        int32_t functionId = pCtx[j].functionId;
-        if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-          continue;
-        }
-        if (functionId < 0) {
-          SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-          doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-          continue;
-        }
-        aAggs[functionId].mergeFunc(&pCtx[j]);
-      }
    }
    savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, i, &pInfo->hasPrev);
@@ -704,11 +672,11 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
  {
    for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-      pCtx[i].pInput = add[i];
+      pCtx[i].pInput = addrPtr[i];
    }
  }
-  tfree(add);
+  tfree(addrPtr);
 }
 static bool isAllSourcesCompleted(SGlobalMerger *pMerger) {
@@ -816,6 +784,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
    SLocalDataSource *pOneDataSrc = pMerger->pLocalDataSrc[pTree->pNode[0].index];
    bool sameGroup = true;
    if (pInfo->hasPrev) {
+      // todo refactor extract method
      int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
      // if this row belongs to current result set group
@@ -955,9 +925,10 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
      break;
    }
+    bool sameGroup = true;
    if (pAggInfo->hasGroupColData) {
-      bool sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
+      sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
-      if (!sameGroup) {
+      if (!sameGroup && !pAggInfo->multiGroupResults) {
        *newgroup = true;
        pAggInfo->hasDataBlockForNewGroup = true;
        pAggInfo->pExistBlock = pBlock;
@@ -976,26 +947,11 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
  }
  if (handleData) { // data in current group is all handled
-    for(int32_t j = 0; j < pOperator->numOfOutput; ++j) {
+    doFinalizeResultImpl(pAggInfo, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
-      int32_t functionId = pAggInfo->binfo.pCtx[j].functionId;
-      if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-        continue;
-      }
-      if (functionId < 0) {
-        SUdfInfo* pUdfInfo = taosArrayGet(pAggInfo->udfInfo, -1 * functionId - 1);
-        doInvokeUdf(pUdfInfo, &pAggInfo->binfo.pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-        continue;
-      }
-      aAggs[functionId].xFinalize(&pAggInfo->binfo.pCtx[j]);
-    }
    int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
-    pAggInfo->binfo.pRes->info.rows += numOfRows;
+    pAggInfo->binfo.pRes->info.rows += numOfRows;
    setTagValueForMultipleRows(pAggInfo->binfo.pCtx, pOperator->numOfOutput, numOfRows);
  }
@@ -1019,71 +975,127 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
  return (pRes->info.rows != 0)? pRes:NULL;
 }
-static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
+static void doHandleDataInCurrentGroup(SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowIndex) {
-  SSLimitOperatorInfo *pInfo = pOperator->info;
+  if (pInfo->currentOffset > 0) {
-  assert(pInfo->currentGroupOffset >= 0);
+    pInfo->currentOffset -= 1;
+  } else {
+    // discard the data rows in current group
+    if (pInfo->limit.limit < 0 || (pInfo->limit.limit >= 0 && pInfo->rowsTotal < pInfo->limit.limit)) {
+      size_t num1 = taosArrayGetSize(pInfo->pRes->pDataBlock);
+      for (int32_t i = 0; i < num1; ++i) {
+        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+        SColumnInfoData *pDstInfoData = taosArrayGet(pInfo->pRes->pDataBlock, i);
-  SSDataBlock* pBlock = NULL;
+        SColumnInfo *pColInfo = &pColInfoData->info;
-  if (pInfo->currentGroupOffset == 0) {
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
+        char *pSrc = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+        char *pDst = (char *)pDstInfoData->pData + (pInfo->pRes->info.rows * pColInfo->bytes);
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-    if (pBlock == NULL) {
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-      pOperator->status = OP_EXEC_DONE;
-    }
-    if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
+        memcpy(pDst, pSrc, pColInfo->bytes);
-      while ((*newgroup) == false) {  // ignore the remain blocks
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-        if (pBlock == NULL) {
-          setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-          pOperator->status = OP_EXEC_DONE;
-          return NULL;
-        }
      }
+      pInfo->rowsTotal += 1;
+      pInfo->pRes->info.rows += 1;
    }
+  }
+}
+static void ensureOutputBuf(SSLimitOperatorInfo * pInfo, SSDataBlock *pResultBlock, int32_t numOfRows) {
+  if (pInfo->capacity < pResultBlock->info.rows + numOfRows) {
+    int32_t total = pResultBlock->info.rows + numOfRows;
+    size_t num = taosArrayGetSize(pResultBlock->pDataBlock);
+    for (int32_t i = 0; i < num; ++i) {
+      SColumnInfoData *pInfoData = taosArrayGet(pResultBlock->pDataBlock, i);
+      char *tmp = realloc(pInfoData->pData, total * pInfoData->info.bytes);
+      if (tmp != NULL) {
+        pInfoData->pData = tmp;
+      } else {
+        // todo handle the malloc failure
+      }
-    return pBlock;
+      pInfo->capacity  = total;
+      pInfo->threshold = (int64_t) (total * 0.8);
+    }
  }
+}
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
+enum {
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+  BLOCK_NEW_GROUP  = 1,
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+  BLOCK_NO_GROUP   = 2,
+  BLOCK_SAME_GROUP = 3,
+};
-    if (pBlock == NULL) {
+static int32_t doSlimitImpl(SOperatorInfo* pOperator, SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock) {
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+  int32_t rowIndex = 0;
-      pOperator->status = OP_EXEC_DONE;
-      return NULL;
+  while (rowIndex < pBlock->info.rows) {
+    int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
+    bool samegroup = true;
+    if (pInfo->hasPrev) {
+      for (int32_t i = 0; i < numOfCols; ++i) {
+        SColIndex       *pIndex = taosArrayGet(pInfo->orderColumnList, i);
+        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, pIndex->colIndex);
+        SColumnInfo *pColInfo = &pColInfoData->info;
+        char   *d = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
+        int32_t ret = columnValueAscendingComparator(pInfo->prevRow[i], d, pColInfo->type, pColInfo->bytes);
+        if (ret != 0) {  // it is a new group
+          samegroup = false;
+          break;
+        }
+      }
    }
-    while(1) {
+    if (!samegroup || !pInfo->hasPrev) {
-      if (*newgroup) {
+      pInfo->ignoreCurrentGroup = false;
-        pInfo->currentGroupOffset -= 1;
+      savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, rowIndex, &pInfo->hasPrev);
-        *newgroup = false;
+      pInfo->currentOffset = pInfo->limit.offset;  // reset the offset value for a new group
+      pInfo->rowsTotal = 0;
+      if (pInfo->currentGroupOffset > 0) {
+        pInfo->ignoreCurrentGroup = true;
+        pInfo->currentGroupOffset -= 1;  // now we are in the next group data
+        rowIndex += 1;
+        continue;
+      }
+      // A new group has arrived according to the result rows, and the group limitation has already reached.
+      // Let's jump out of current loop and return immediately.
+      if (pInfo->slimit.limit >= 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
+        setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+        pOperator->status = OP_EXEC_DONE;
+        return BLOCK_NO_GROUP;
      }
-      while ((*newgroup) == false) {
+      pInfo->groupTotal += 1;
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-        if (pBlock == NULL) {
+      // data in current group not allowed, return if current result does not belong to the previous group.And there
-          setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+      // are results exists in current SSDataBlock
-          pOperator->status = OP_EXEC_DONE;
+      if (!pInfo->multigroupResult && !samegroup && pInfo->pRes->info.rows > 0) {
-          return NULL;
+        return BLOCK_NEW_GROUP;
-        }
      }
-      // now we have got the first data block of the next group.
+      doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
-      if (pInfo->currentGroupOffset == 0) {
-        return pBlock;
+    } else {  // handle the offset in the same group
+      // All the data in current group needs to be discarded, due to the limit parameter in the SQL statement
+      if (pInfo->ignoreCurrentGroup) {
+        rowIndex += 1;
+        continue;
      }
+      doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
    }
-  return NULL;
+    rowIndex += 1;
+  }
+  return BLOCK_SAME_GROUP;
 }
 SSDataBlock* doSLimit(void* param, bool* newgroup) {
@@ -1093,63 +1105,41 @@ SSDataBlock* doSLimit(void* param, bool* newgroup) {
  }
  SSLimitOperatorInfo *pInfo = pOperator->info;
+  pInfo->pRes->info.rows = 0;
-  SSDataBlock *pBlock = NULL;
+  if (pInfo->pPrevBlock != NULL) {
-  while (1) {
+    ensureOutputBuf(pInfo, pInfo->pRes, pInfo->pPrevBlock->info.rows);
-    pBlock = skipGroupBlock(pOperator, newgroup);
+    int32_t ret = doSlimitImpl(pOperator, pInfo, pInfo->pPrevBlock);
-    if (pBlock == NULL) {
+    assert(ret != BLOCK_NEW_GROUP);
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-      pOperator->status = OP_EXEC_DONE;
-      return NULL;
-    }
-    if (*newgroup) {  // a new group arrives
-      pInfo->groupTotal += 1;
-      pInfo->rowsTotal = 0;
-      pInfo->currentOffset = pInfo->limit.offset;
-    }
-    assert(pInfo->currentGroupOffset == 0);
+    pInfo->pPrevBlock = NULL;
+  }
-    if (pInfo->currentOffset >= pBlock->info.rows) {
-      pInfo->currentOffset -= pBlock->info.rows;
-    } else {
-      if (pInfo->currentOffset == 0) {
-        break;
-      }
-      int32_t remain = (int32_t)(pBlock->info.rows - pInfo->currentOffset);
-      pBlock->info.rows = remain;
-      // move the remain rows of this data block to the front.
+  assert(pInfo->currentGroupOffset >= 0);
-      for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
-        int16_t bytes = pColInfoData->info.bytes;
+  while(1) {
-        memmove(pColInfoData->pData, pColInfoData->pData + bytes * pInfo->currentOffset, remain * bytes);
+    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-      }
+    SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-      pInfo->currentOffset = 0;
+    if (pBlock == NULL) {
-      break;
+      return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
    }
-  }
-  if (pInfo->slimit.limit > 0 && pInfo->groupTotal > pInfo->slimit.limit) {  // reach the group limit, abort
-    return NULL;
-  }
-  if (pInfo->limit.limit > 0 && (pInfo->rowsTotal + pBlock->info.rows >= pInfo->limit.limit)) {
+    ensureOutputBuf(pInfo, pInfo->pRes, pBlock->info.rows);
-    pBlock->info.rows = (int32_t)(pInfo->limit.limit - pInfo->rowsTotal);
+    int32_t ret = doSlimitImpl(pOperator, pInfo, pBlock);
-    pInfo->rowsTotal = pInfo->limit.limit;
+    if (ret == BLOCK_NEW_GROUP) {
+      pInfo->pPrevBlock = pBlock;
+      return pInfo->pRes;
+    }
-    if (pInfo->slimit.limit > 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
+    if (pOperator->status == OP_EXEC_DONE) {
-      pOperator->status = OP_EXEC_DONE;
+      return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
    }
-    //    setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+    // now the number of rows in current group is enough, let's return to the invoke function
-  } else {
+    if (pInfo->pRes->info.rows > pInfo->threshold) {
-    pInfo->rowsTotal += pBlock->info.rows;
+      return pInfo->pRes;
+    }
  }
-  return pBlock;
 }
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -114,7 +114,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
  }
  for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
-    if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+    if (isspace(pToken->z[k])) continue;
    if (pToken->z[k] == ',') {
      *next = pTokenEnd;
      *time = useconds;
@@ -1589,7 +1589,8 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
    ret = tsParseInsertSql(pSql);
    if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION)) {
-      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+      SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, msg:%s, clear meta cache and retry ", pSql->self, pInsertParam->msg, tstrerror(ret));
      tscResetSqlCmd(pCmd, true);
      pSql->parseRetry++;
@@ -1757,6 +1758,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
      pSql->res.numOfRows = 0;
      code = doPackSendDataBlock(pSql, pInsertParam, pTableMeta, count, pTableDataBlock);
      if (code != TSDB_CODE_SUCCESS) {
+        pParentSql->res.code = code;
        goto _error;
      }
@@ -1777,6 +1779,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
  }
 _error:
+  pParentSql->res.code = code;
  tfree(tokenBuf);
  tfree(line);
  taos_free_result(pSql);

--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -86,6 +86,10 @@ typedef struct STscStmt {
  return _code;             \
 } while (0)
+#define STMT_CHECK if (pStmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) { \
+                      STMT_RET(TSDB_CODE_TSC_DISCONNECTED);  \
+                    }
 static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
  return tscInvalidOperationMsg(dstBuffer, errMsg, NULL);
 }
@@ -155,6 +159,22 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
        var->i64 = *(int64_t*)tb->buffer;
        break;
+      case  TSDB_DATA_TYPE_UTINYINT:
+        var->u64 = *(uint8_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_USMALLINT:
+        var->u64 = *(uint16_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_UINT:
+        var->u64 = *(uint32_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_UBIGINT:
+        var->u64 = *(uint64_t*)tb->buffer;
+        break;
      case TSDB_DATA_TYPE_FLOAT:
        var->dKey = GET_FLOAT_VAL(tb->buffer);
        break;
@@ -206,6 +226,8 @@ static int normalStmtPrepare(STscStmt* stmt) {
        return code;
      }
      start = i + token.n;
+    } else if (token.type == TK_ILLEGAL) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(&stmt->pSql->cmd), "invalid sql");
    }
    i += token.n;
@@ -259,9 +281,17 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
      taosStringBuilderAppendInteger(&sb, var->i64);
      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+      taosStringBuilderAppendUnsignedInteger(&sb, var->u64);
+      break;
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
      taosStringBuilderAppendDouble(&sb, var->dKey);
@@ -1492,6 +1522,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
  pSql->isBind    = true;
  pStmt->pSql     = pSql;
  pStmt->last     = STMT_INIT;
+  registerSqlObj(pSql);
  return pStmt;
 }
@@ -1499,9 +1530,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
 int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (sql == NULL) {
    tscError("sql is NULL");
@@ -1547,8 +1576,6 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
    pSql->cmd.insertParam.numOfParams = 0;
    pSql->cmd.batchSize   = 0;
-    registerSqlObj(pSql);
    int32_t ret = stmtParseInsertTbTags(pSql, pStmt);
    if (ret != TSDB_CODE_SUCCESS) {
      STMT_RET(ret);
@@ -1578,9 +1605,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
  STscStmt* pStmt = (STscStmt*)stmt;
  int32_t code = 0;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  SSqlObj* pSql = pStmt->pSql;
  SSqlCmd* pCmd = &pSql->cmd;
@@ -1740,6 +1765,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
 int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
  pStmt->mtb.subSet = true;
  return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1748,6 +1774,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
 int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
  pStmt->mtb.subSet = false;
  return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1755,6 +1782,9 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 int taos_stmt_close(TAOS_STMT* stmt) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  if (pStmt == NULL || pStmt->taos == NULL) {
+    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
+  }
  if (!pStmt->isInsert) {
    SNormalStmt* normal = &pStmt->normal;
    if (normal->params != NULL) {
@@ -1776,8 +1806,9 @@ int taos_stmt_close(TAOS_STMT* stmt) {
      pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, rmMeta);
      if (pStmt->pSql){
        taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
+        pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
      }
-      pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
      taosArrayDestroy(pStmt->mtb.tags);
      tfree(pStmt->mtb.sqlstr);
    }
@@ -1790,9 +1821,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
 int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->multiTbInsert) {
@@ -1821,9 +1850,7 @@ int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
 int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1854,9 +1881,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
 int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX || colIdx < 0) {
    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1889,9 +1914,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, in
 int taos_stmt_add_batch(TAOS_STMT* stmt) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
@@ -1918,9 +1941,7 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
 int taos_stmt_execute(TAOS_STMT* stmt) {
  int ret = 0;
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->last != STMT_ADD_BATCH) {
@@ -1941,11 +1962,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
    if (sql == NULL) {
      ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
    } else {
-      if (pStmt->pSql != NULL) {
+      taosReleaseRef(tscObjRef, pStmt->pSql->self);
-        tscFreeSqlObj(pStmt->pSql);
-        pStmt->pSql = NULL;
-      }
      pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
      ret = taos_errno(pStmt->pSql);
      free(sql);
@@ -1966,7 +1983,6 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
    tscError("result has been used already.");
    return NULL;
  }
  TAOS_RES* result = pStmt->pSql;
  pStmt->pSql = NULL;
  return result;
@@ -1975,9 +1991,7 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
 int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (insert) *insert = pStmt->isInsert;
@@ -1987,9 +2001,7 @@ int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
 int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    SSqlObj* pSql = pStmt->pSql;
@@ -2006,9 +2018,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
 int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    SSqlCmd* pCmd = &pStmt->pSql->cmd;

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -337,16 +337,189 @@ int tscSendMsgToServer(SSqlObj *pSql) {
  return TSDB_CODE_SUCCESS;
 }
-static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
+//static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
-  SRpcMsg* rpcMsg = pSchedMsg->ahandle;
+//  SRpcMsg* rpcMsg = pSchedMsg->ahandle;
-  SRpcEpSet* pEpSet = pSchedMsg->thandle;
+//  SRpcEpSet* pEpSet = pSchedMsg->thandle;
+//
+//  TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
+//  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
+//  if (pSql == NULL) {
+//    rpcFreeCont(rpcMsg->pCont);
+//    free(rpcMsg);
+//    free(pEpSet);
+//    return;
+//  }
+//
+//  assert(pSql->self == handle);
+//
+//  STscObj *pObj = pSql->pTscObj;
+//  SSqlRes *pRes = &pSql->res;
+//  SSqlCmd *pCmd = &pSql->cmd;
+//
+//  pSql->rpcRid = -1;
+//
+//  if (pObj->signature != pObj) {
+//    tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
+//
+//    taosRemoveRef(tscObjRef, handle);
+//    taosReleaseRef(tscObjRef, handle);
+//    rpcFreeCont(rpcMsg->pCont);
+//    free(rpcMsg);
+//    free(pEpSet);
+//    return;
+//  }
+//
+//  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+//  if (pQueryInfo != NULL && pQueryInfo->type == TSDB_QUERY_TYPE_FREE_RESOURCE) {
+//    tscDebug("0x%"PRIx64" sqlObj needs to be released or DB connection is closed, cmd:%d type:%d, pObj:%p signature:%p",
+//        pSql->self, pCmd->command, pQueryInfo->type, pObj, pObj->signature);
+//
+//    taosRemoveRef(tscObjRef, handle);
+//    taosReleaseRef(tscObjRef, handle);
+//    rpcFreeCont(rpcMsg->pCont);
+//    free(rpcMsg);
+//    free(pEpSet);
+//    return;
+//  }
+//
+//  if (pEpSet) {
+//    if (!tscEpSetIsEqual(&pSql->epSet, pEpSet)) {
+//      if (pCmd->command < TSDB_SQL_MGMT) {
+//        tscUpdateVgroupInfo(pSql, pEpSet);
+//      } else {
+//        tscUpdateMgmtEpSet(pSql, pEpSet);
+//      }
+//    }
+//  }
+//
+//  int32_t cmd = pCmd->command;
+//
+//  // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
+//  if (cmd == TSDB_SQL_INSERT && rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+//    pSql->cmd.insertParam.schemaAttached = 1;
+//  }
+//
+//  // single table query error need to be handled here.
+//  if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
+//      (((rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID)) ||
+//       rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
+//
+//    // 1. super table subquery
+//    // 2. nest queries are all not updated the tablemeta and retry parse the sql after cleanup local tablemeta/vgroup id buffer
+//    if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
+//                                               TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
+//                                               !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
+//                                               (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)) {
+//      // do nothing in case of super table subquery
+//    }  else {
+//      pSql->retry += 1;
+//      tscWarn("0x%" PRIx64 " it shall renew table meta, code:%s, retry:%d", pSql->self, tstrerror(rpcMsg->code), pSql->retry);
+//
+//      pSql->res.code = rpcMsg->code;  // keep the previous error code
+//      if (pSql->retry > pSql->maxRetry) {
+//        tscError("0x%" PRIx64 " max retry %d reached, give up", pSql->self, pSql->maxRetry);
+//      } else {
+//        // wait for a little bit moment and then retry
+//        // todo do not sleep in rpc callback thread, add this process into queue to process
+//        if (rpcMsg->code == TSDB_CODE_APP_NOT_READY || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
+//          int32_t duration = getWaitingTimeInterval(pSql->retry);
+//          taosMsleep(duration);
+//        }
+//
+//        pSql->retryReason = rpcMsg->code;
+//        rpcMsg->code = tscRenewTableMeta(pSql, 0);
+//        // if there is an error occurring, proceed to the following error handling procedure.
+//        if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+//          taosReleaseRef(tscObjRef, handle);
+//          rpcFreeCont(rpcMsg->pCont);
+//          free(rpcMsg);
+//          free(pEpSet);
+//          return;
+//        }
+//      }
+//    }
+//  }
+//
+//  pRes->rspLen = 0;
+//
+//  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+//    tscDebug("0x%"PRIx64" query is cancelled, code:%s", pSql->self, tstrerror(pRes->code));
+//  } else {
+//    pRes->code = rpcMsg->code;
+//  }
+//
+//  if (pRes->code == TSDB_CODE_SUCCESS) {
+//    tscDebug("0x%"PRIx64" reset retry counter to be 0 due to success rsp, old:%d", pSql->self, pSql->retry);
+//    pSql->retry = 0;
+//  }
+//
+//  if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) {
+//    assert(rpcMsg->msgType == pCmd->msgType + 1);
+//    pRes->code    = rpcMsg->code;
+//    pRes->rspType = rpcMsg->msgType;
+//    pRes->rspLen  = rpcMsg->contLen;
+//
+//    if (pRes->rspLen > 0 && rpcMsg->pCont) {
+//      char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
+//      if (tmp == NULL) {
+//        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+//      } else {
+//        pRes->pRsp = tmp;
+//        memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
+//      }
+//    } else {
+//      tfree(pRes->pRsp);
+//    }
+//
+//    /*
+//     * There is not response callback function for submit response.
+//     * The actual inserted number of points is the first number.
+//     */
+//    if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP && pRes->pRsp != NULL) {
+//      SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
+//      pMsg->code = htonl(pMsg->code);
+//      pMsg->numOfRows = htonl(pMsg->numOfRows);
+//      pMsg->affectedRows = htonl(pMsg->affectedRows);
+//      pMsg->failedRows = htonl(pMsg->failedRows);
+//      pMsg->numOfFailedBlocks = htonl(pMsg->numOfFailedBlocks);
+//
+//      pRes->numOfRows += pMsg->affectedRows;
+//      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s inserted rows:%d rspLen:%d", pSql->self, sqlCmd[pCmd->command],
+//          tstrerror(pRes->code), pMsg->affectedRows, pRes->rspLen);
+//    } else {
+//      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s rspLen:%d", pSql->self, sqlCmd[pCmd->command], tstrerror(pRes->code), pRes->rspLen);
+//    }
+//  }
+//
+//  if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) {
+//    rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
+//  }
+//
+//  bool shouldFree = tscShouldBeFreed(pSql);
+//  if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+//    if (rpcMsg->code != TSDB_CODE_SUCCESS) {
+//      pRes->code = rpcMsg->code;
+//    }
+//    rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
+//    (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
+//  }
+//
+//  if (shouldFree) { // in case of table-meta/vgrouplist query, automatically free it
+//    tscDebug("0x%"PRIx64" sqlObj is automatically freed", pSql->self);
+//    taosRemoveRef(tscObjRef, handle);
+//  }
+//
+//  taosReleaseRef(tscObjRef, handle);
+//  rpcFreeCont(rpcMsg->pCont);
+//  free(rpcMsg);
+//  free(pEpSet);
+//}
+void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
  TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
  if (pSql == NULL) {
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -357,15 +530,12 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
  SSqlCmd *pCmd = &pSql->cmd;
  pSql->rpcRid = -1;
  if (pObj->signature != pObj) {
    tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
    taosRemoveRef(tscObjRef, handle);
    taosReleaseRef(tscObjRef, handle);
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -377,8 +547,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
    taosRemoveRef(tscObjRef, handle);
    taosReleaseRef(tscObjRef, handle);
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -409,7 +577,8 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
    if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
                                               TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
                                               !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
-                                               (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)) {
+                                               (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)
+                                              || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY))) {
      // do nothing in case of super table subquery
    }  else {
      pSql->retry += 1;
@@ -432,8 +601,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
        if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
          taosReleaseRef(tscObjRef, handle);
          rpcFreeCont(rpcMsg->pCont);
-          free(rpcMsg);
-          free(pEpSet);
          return;
        }
      }
@@ -511,29 +678,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
  taosReleaseRef(tscObjRef, handle);
  rpcFreeCont(rpcMsg->pCont);
-  free(rpcMsg);
-  free(pEpSet);
-}
-void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
-  SSchedMsg schedMsg = {0};
-  schedMsg.fp = doProcessMsgFromServer;
-  SRpcMsg* rpcMsgCopy = calloc(1, sizeof(SRpcMsg));
-  memcpy(rpcMsgCopy, rpcMsg, sizeof(struct SRpcMsg));
-  schedMsg.ahandle = (void*)rpcMsgCopy;
-  SRpcEpSet* pEpSetCopy = NULL;
-  if (pEpSet != NULL) {
-    pEpSetCopy = calloc(1, sizeof(SRpcEpSet));
-    memcpy(pEpSetCopy, pEpSet, sizeof(SRpcEpSet));
-  }
-  schedMsg.thandle = (void*)pEpSetCopy;
-  schedMsg.msg = NULL;
-  taosScheduleTask(tscQhandle, &schedMsg);
 }
 int doBuildAndSendMsg(SSqlObj *pSql) {
@@ -698,6 +842,11 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql) {
    tableSerialize = totalTables * sizeof(STableIdInfo);
  }
+  SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
+  if (pCond->len > 0) {
+    srcColListSize += pCond->len;
+  }
  return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + srcColFilterSize + srcTagFilterSize +
         exprSize + tsBufSize + tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
 }
@@ -852,8 +1001,8 @@ static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo,
  (*pMsg) += sizeof(SSqlExpr);
  for (int32_t j = 0; j < pExpr->numOfParams; ++j) { // todo add log
-    pSqlExpr->param[j].nType = htons((uint16_t)pExpr->param[j].nType);
+    pSqlExpr->param[j].nType = htonl(pExpr->param[j].nType);
-    pSqlExpr->param[j].nLen = htons(pExpr->param[j].nLen);
+    pSqlExpr->param[j].nLen  = htonl(pExpr->param[j].nLen);
    if (pExpr->param[j].nType == TSDB_DATA_TYPE_BINARY) {
      memcpy((*pMsg), pExpr->param[j].pz, pExpr->param[j].nLen);
@@ -958,6 +1107,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
    pQueryMsg->tableCols[i].bytes = htons(pCol->bytes);
    pQueryMsg->tableCols[i].type  = htons(pCol->type);
    pQueryMsg->tableCols[i].flist.numOfFilters = htons(pCol->flist.numOfFilters);
+    pQueryMsg->tableCols[i].flist.filterInfo = 0;
    // append the filter information after the basic column information
    serializeColFilterInfo(pCol->flist.filterInfo, pCol->flist.numOfFilters, &pMsg);
@@ -1040,6 +1190,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
      pMsg += pCond->len;
    }
+  } else {
+    pQueryMsg->tagCondLen = 0;
  }
  if (pQueryInfo->bufLen > 0) {
@@ -1069,6 +1221,9 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
    pQueryMsg->tsBuf.tsOrder = htonl(pQueryInfo->tsBuf->tsOrder);
    pQueryMsg->tsBuf.tsLen   = htonl(pQueryMsg->tsBuf.tsLen);
    pQueryMsg->tsBuf.tsNumOfBlocks = htonl(pQueryMsg->tsBuf.tsNumOfBlocks);
+  }  else {
+    pQueryMsg->tsBuf.tsLen = 0;
+    pQueryMsg->tsBuf.tsNumOfBlocks = 0;
  }
  int32_t numOfOperator = (int32_t) taosArrayGetSize(queryOperator);
@@ -1106,6 +1261,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
      pMsg += pUdfInfo->contLen;
    }
+  } else {
+    pQueryMsg->udfContentOffset = 0;
  }
  memcpy(pMsg, pSql->sqlstr, sqlLen);
@@ -1383,7 +1540,6 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
 }
 int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  STscObj *pObj = pSql->pTscObj;
  SSqlCmd *pCmd = &pSql->cmd;
  pCmd->msgType = TSDB_MSG_TYPE_CM_SHOW;
  pCmd->payloadLen = sizeof(SShowMsg) + 100;
@@ -1406,9 +1562,9 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  }
  if (tNameIsEmpty(&pTableMetaInfo->name)) {
-    pthread_mutex_lock(&pObj->mutex);
+    char *p = cloneCurrentDBName(pSql);
-    tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));  
+    tstrncpy(pShowMsg->db, p, sizeof(pShowMsg->db));
-    pthread_mutex_unlock(&pObj->mutex);
+    tfree(p);
  } else {
    tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
  }
@@ -1744,7 +1900,7 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
      return pRes->code;
    }
-    tscSetResRawPtr(pRes, pQueryInfo);
+    tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
  } else {
    tscResetForNextRetrieve(pRes);
  }
@@ -2149,7 +2305,7 @@ static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t
      pVgroup->vgId = vmsg->vgId;
      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
        pVgroup->epAddr[k].port = vmsg->epAddr[k].port;
-        pVgroup->epAddr[k].fqdn = strndup(vmsg->epAddr[k].fqdn, TSDB_FQDN_LEN);
+        tstrncpy(pVgroup->epAddr[k].fqdn, vmsg->epAddr[k].fqdn, TSDB_FQDN_LEN);
      }
      doUpdateVgroupInfo(pVgroup->vgId, vmsg);
@@ -2207,6 +2363,7 @@ int tscProcessRetrieveFuncRsp(SSqlObj* pSql) {
  parQueryInfo->pUdfInfo = pQueryInfo->pUdfInfo;   // assigned to parent sql obj.
  pQueryInfo->pUdfInfo = NULL;
+  taosReleaseRef(tscObjRef, parent->self);
  return TSDB_CODE_SUCCESS;
 }
@@ -2659,7 +2816,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
      (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
       !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY) &&
       !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE))) {
-    tscSetResRawPtr(pRes, pQueryInfo);
+    tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
  }
  if (pSql->pSubscription != NULL) {
@@ -2824,7 +2981,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
      pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
  pNew->fp = fp;
-  pNew->param = (void *)pSql->self;
+  pNew->param = (void *)pSql->rootObj->self;
  tscDebug("0x%"PRIx64" metaRid from 0x%" PRIx64 " to 0x%" PRIx64 , pSql->self, pSql->metaRid, pNew->self);
@@ -2849,17 +3006,23 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
      memset(pTableMetaInfo->pTableMeta, 0, pTableMetaInfo->tableMetaCapacity);
    } 
  } 
-  taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity);
+  if (NULL == taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity)) {
+    tfree(pTableMetaInfo->pTableMeta);
+    pTableMetaInfo->tableMetaCapacity = 0;
+  }
  STableMeta* pMeta = pTableMetaInfo->pTableMeta;
  if (pMeta && pMeta->id.uid > 0) {
    // in case of child table, here only get the
    if (pMeta->tableType == TSDB_CHILD_TABLE) {
      int32_t code = tscCreateTableMetaFromSTableMeta(&pTableMetaInfo->pTableMeta, name, &pTableMetaInfo->tableMetaCapacity);
+      pMeta   = pTableMetaInfo->pTableMeta;
      if (code != TSDB_CODE_SUCCESS) {
        return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
      }
    }
+    tscDebug("0x%"PRIx64 " %s retrieve tableMeta from cache, numOfCols:%d, numOfTags:%d", pSql->self, name, pMeta->tableInfo.numOfColumns, pMeta->tableInfo.numOfTags);
    return TSDB_CODE_SUCCESS;
  }
@@ -2967,6 +3130,12 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
  pCmd->pTableMetaMap = tscCleanupTableMetaMap(pCmd->pTableMetaMap);
  pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  SSqlCmd* pCmd2 = &pSql->rootObj->cmd;
+  pCmd2->pTableMetaMap = tscCleanupTableMetaMap(pCmd2->pTableMetaMap);
+  pCmd2->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  pSql->rootObj->retryReason = pSql->retryReason;
  SArray* pNameList = taosArrayInit(1, POINTER_BYTES);
  SArray* vgroupList = taosArrayInit(1, POINTER_BYTES);

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -874,6 +874,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  pSql->pTscObj  = taos;
  pSql->signature = pSql;
+  pSql->rootObj = pSql;
  SSqlCmd *pCmd = &pSql->cmd;
  pCmd->resColumnId = TSDB_RES_COL_ID;
@@ -982,6 +983,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  pSql->pTscObj   = taos;
  pSql->signature = pSql;
+  pSql->rootObj = pSql;
  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
  free(str);

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -679,6 +679,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
  pSql->signature = pSql;
  pSql->pTscObj = pObj;
+  pSql->rootObj = pSql;
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;

--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -127,6 +127,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
  pSql->signature = pSql;
  pSql->pTscObj = pObj;
  pSql->pSubscription = pSub;
+  pSql->rootObj = pSql;
  pSub->pSql = pSql;
  SSqlCmd* pCmd = &pSql->cmd;

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -122,6 +122,10 @@ int32_t tscAcquireRpc(const char *key, const char *user, const char *secretEncry
 void taos_init_imp(void) {
  char temp[128] = {0};
+  // In the APIs of other program language, taos_cleanup is not available yet.
+  // So, to make sure taos_cleanup will be invoked to clean up the allocated resource to suppress the valgrind warning.
+  atexit(taos_cleanup);
  errno = TSDB_CODE_SUCCESS;
  srand(taosGetTimestampSec());
@@ -197,10 +201,6 @@ void taos_init_imp(void) {
  tscRefId = taosOpenRef(200, tscCloseTscObj);
-  // In the APIs of other program language, taos_cleanup is not available yet.
-  // So, to make sure taos_cleanup will be invoked to clean up the allocated resource to suppress the valgrind warning.
-  atexit(taos_cleanup);
  tscDebug("client is initialized successfully");
 }

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -29,6 +29,7 @@
 #include "tsclient.h"
 #include "ttimer.h"
 #include "ttokendef.h"
+#include "httpInt.h"
 static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
@@ -60,6 +61,21 @@ int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *le
    case TSDB_DATA_TYPE_TIMESTAMP:
      n = sprintf(str, "%" PRId64, *(int64_t*)buf);
      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      n = sprintf(str, "%d", *(uint8_t*)buf);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      n = sprintf(str, "%d", *(uint16_t*)buf);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      n = sprintf(str, "%d", *(uint32_t*)buf);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      n = sprintf(str, "%" PRId64, *(uint64_t*)buf);
+      break;
    case TSDB_DATA_TYPE_FLOAT:
      n = sprintf(str, "%f", GET_FLOAT_VAL(buf));
@@ -675,9 +691,13 @@ static void setResRawPtrImpl(SSqlRes* pRes, SInternalField* pInfo, int32_t i, bo
    memcpy(pRes->urow[i], pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
  }
+  if (convertNchar) {
+    pRes->dataConverted = true;
+  }
 }
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted) {
  assert(pRes->numOfCols > 0);
  if (pRes->numOfRows == 0) {
    return;
@@ -690,7 +710,7 @@ void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
    pRes->length[i] = pInfo->field.bytes;
    offset += pInfo->field.bytes;
-    setResRawPtrImpl(pRes, pInfo, i, true);
+    setResRawPtrImpl(pRes, pInfo, i, converted ? false : true);
  }
 }
@@ -1496,6 +1516,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
    return;
  }
+  int64_t sid = pSql->self;
  tscDebug("0x%"PRIx64" start to free sqlObj", pSql->self);
  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
@@ -1527,6 +1549,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
  tfree(pCmd->payload);
  pCmd->allocSize = 0;
+  tscDebug("0x%"PRIx64" addr:%p free completed", sid, pSql);
  tsem_destroy(&pSql->rspSem);
  memset(pSql, 0, sizeof(*pSql));
  free(pSql);
@@ -2093,6 +2117,22 @@ TAOS_FIELD tscCreateField(int8_t type, const char* name, int16_t bytes) {
  return f;
 }
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo) { 
+  if (pQueryInfo->fieldsInfo.numOfOutput <= 0 || pQueryInfo->fieldsInfo.internalField == NULL) {
+    return 0;
+  }
+  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
+    SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
+    if (!pField->visible) {
+      return i;
+    }    
+  }
+  return pQueryInfo->fieldsInfo.numOfOutput; 
+}
 SInternalField* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField) {
  assert(pFieldInfo != NULL);
  pFieldInfo->numOfOutput++;
@@ -3062,6 +3102,7 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
  pQueryInfo->slimit.offset  = 0;
  pQueryInfo->pUpstream      = taosArrayInit(4, POINTER_BYTES);
  pQueryInfo->window         = TSWINDOW_INITIALIZER;
+  pQueryInfo->multigroupResult = true;
 }
 int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
@@ -3073,7 +3114,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
  }
  tscInitQueryInfo(pQueryInfo);
  pQueryInfo->msg = pCmd->payload;  // pointer to the parent error message buffer
  if (pCmd->pQueryInfo == NULL) {
@@ -3155,6 +3195,7 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
  pQueryInfo->window         = pSrc->window;
  pQueryInfo->sessionWindow  = pSrc->sessionWindow;
  pQueryInfo->pTableMetaInfo = NULL;
+  pQueryInfo->multigroupResult = pSrc->multigroupResult;
  pQueryInfo->bufLen         = pSrc->bufLen;
  pQueryInfo->orderProjectQuery = pSrc->orderProjectQuery;
@@ -3241,11 +3282,6 @@ void tscFreeVgroupTableInfo(SArray* pVgroupTables) {
  size_t num = taosArrayGetSize(pVgroupTables);
  for (size_t i = 0; i < num; i++) {
    SVgroupTableInfo* pInfo = taosArrayGet(pVgroupTables, i);
-    for(int32_t j = 0; j < pInfo->vgInfo.numOfEps; ++j) {
-      tfree(pInfo->vgInfo.epAddr[j].fqdn);
-    }
    taosArrayDestroy(pInfo->itemList);
  }
@@ -3259,10 +3295,6 @@ void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index) {
  assert(size > index);
  SVgroupTableInfo* pInfo = taosArrayGet(pVgroupTable, index);
-  for(int32_t j = 0; j < pInfo->vgInfo.numOfEps; ++j) {
-    tfree(pInfo->vgInfo.epAddr[j].fqdn);
-  }
  taosArrayDestroy(pInfo->itemList);
  taosArrayRemove(pVgroupTable, index);
 }
@@ -3271,10 +3303,6 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo) {
  memset(info, 0, sizeof(SVgroupTableInfo));
  info->vgInfo = pInfo->vgInfo;
-  for(int32_t j = 0; j < pInfo->vgInfo.numOfEps; ++j) {
-    info->vgInfo.epAddr[j].fqdn = strdup(pInfo->vgInfo.epAddr[j].fqdn);
-  }
  if (pInfo->itemList) {
    info->itemList = taosArrayDup(pInfo->itemList);
  }
@@ -3392,6 +3420,7 @@ void tscResetForNextRetrieve(SSqlRes* pRes) {
  pRes->row = 0;
  pRes->numOfRows = 0;
+  pRes->dataConverted = false;
 }
 void tscInitResForMerge(SSqlRes* pRes) {
@@ -3421,6 +3450,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
  pNew->pTscObj = pSql->pTscObj;
  pNew->signature = pNew;
+  pNew->rootObj = pSql->rootObj;
  SSqlCmd* pCmd = &pNew->cmd;
  pCmd->command = cmd;
@@ -3501,7 +3531,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
  pNew->pTscObj   = pSql->pTscObj;
  pNew->signature = pNew;
-  pNew->sqlstr    = strdup(pSql->sqlstr);
+  pNew->sqlstr    = strdup(pSql->sqlstr);  
+  pNew->rootObj   = pSql->rootObj;
  tsem_init(&pNew->rspSem, 0, 0);
  SSqlCmd* pnCmd  = &pNew->cmd;
@@ -3554,7 +3585,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
  pNewQueryInfo->pTableMetaInfo = NULL;
  pNewQueryInfo->bufLen = pQueryInfo->bufLen;
  pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
+  pNewQueryInfo->multigroupResult = pQueryInfo->multigroupResult;
  pNewQueryInfo->distinct =  pQueryInfo->distinct;
  if (pNewQueryInfo->buf == NULL) {
@@ -3777,40 +3808,57 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
    // todo refactor
    tscDebug("0x%"PRIx64" all subquery response received, retry", pParentSql->self);
-    if (code && !((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && pParentSql->retry < pParentSql->maxRetry)) {
+    SSqlObj *rootObj = pParentSql->rootObj;
+    if (code && !((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && rootObj->retry < rootObj->maxRetry)) {
+      pParentSql->res.code = code;
      tscAsyncResultOnError(pParentSql);
      return;
    }
-    tscFreeSubobj(pParentSql);    
+    tscFreeSubobj(pParentSql);
    tfree(pParentSql->pSubs);
-    pParentSql->res.code = TSDB_CODE_SUCCESS;
+    tscFreeSubobj(rootObj);
-    pParentSql->retry++;
+    tfree(rootObj->pSubs);
-    tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
+    rootObj->res.code = TSDB_CODE_SUCCESS;
-             tstrerror(code), pParentSql->retry);
+    rootObj->retry++;
+    tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", rootObj->self,
-    tscResetSqlCmd(&pParentSql->cmd, true);
+             tstrerror(code), rootObj->retry);
-    code = tsParseSql(pParentSql, true);
+    tscResetSqlCmd(&rootObj->cmd, true);
+    code = tsParseSql(rootObj, true);
    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
      return;
    }
    if (code != TSDB_CODE_SUCCESS) {
-      pParentSql->res.code = code;
+      rootObj->res.code = code;
-      tscAsyncResultOnError(pParentSql);
+      tscAsyncResultOnError(rootObj);
      return;
    }
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(&rootObj->cmd);
-    executeQuery(pParentSql, pQueryInfo);
+    executeQuery(rootObj, pQueryInfo);
+    return;
+  }
+  if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+    SSqlObj* pParentSql = ps->pParentSql;
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+    (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
    return;
  }
  taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
 }
@@ -3858,10 +3906,12 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
      pNew->signature = pNew;
      pNew->sqlstr    = strdup(pSql->sqlstr);
      pNew->fp        = tscSubqueryCompleteCallback;
-      pNew->maxRetry  = pSql->maxRetry;
+      pNew->fetchFp   = tscSubqueryCompleteCallback;
+      pNew->maxRetry  = pSql->maxRetry;      
+      pNew->rootObj   = pSql->rootObj;
      pNew->cmd.resColumnId = TSDB_RES_COL_ID;
      tsem_init(&pNew->rspSem, 0, 0);
      SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));  // todo use object id
@@ -4038,6 +4088,31 @@ int32_t tscInvalidOperationMsg(char* msg, const char* additionalInfo, const char
  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql) {
+  const char* msgFormat1 = "%s:%s";
+  const char* msgFormat2 = "%s:\'%s\' (%s)";
+  const char* msgFormat3 = "%s:\'%s\'";
+  const int32_t BACKWARD_CHAR_STEP = 0;
+  if (sql == NULL) {
+    assert(errMsg != NULL);
+    sprintf(dstBuffer, msgFormat1, tstrerror(code), errMsg);
+    return code;
+  }
+  char buf[64] = {0};  // only extract part of sql string
+  strncpy(buf, (sql - BACKWARD_CHAR_STEP), tListLen(buf) - 1);
+  if (errMsg != NULL) {
+    sprintf(dstBuffer, msgFormat2, tstrerror(code), buf, errMsg);
+  } else {
+    sprintf(dstBuffer, msgFormat3, tstrerror(code), buf);  // no additional information for invalid sql error
+  }
+  return code;
+}
 bool tscHasReachLimitation(SQueryInfo* pQueryInfo, SSqlRes* pRes) {
  assert(pQueryInfo != NULL && pQueryInfo->clauseLimit != 0);
  return (pQueryInfo->clauseLimit > 0 && pRes->numOfClauseTotal >= pQueryInfo->clauseLimit);
@@ -4262,12 +4337,12 @@ SVgroupsInfo* tscVgroupInfoClone(SVgroupsInfo *vgroupList) {
    SVgroupInfo* pNewVInfo = &pNew->vgroups[i];
    SVgroupInfo* pvInfo = &vgroupList->vgroups[i];
-    pNewVInfo->vgId = pvInfo->vgId;
+    pNewVInfo->vgId     = pvInfo->vgId;
    pNewVInfo->numOfEps = pvInfo->numOfEps;
    for(int32_t j = 0; j < pvInfo->numOfEps; ++j) {
-      pNewVInfo->epAddr[j].fqdn = strdup(pvInfo->epAddr[j].fqdn);
+        tstrncpy(pNewVInfo->epAddr[j].fqdn, pvInfo->epAddr[j].fqdn, TSDB_FQDN_LEN);
-      pNewVInfo->epAddr[j].port = pvInfo->epAddr[j].port;
+        pNewVInfo->epAddr[j].port = pvInfo->epAddr[j].port;
    }
  }
@@ -4279,34 +4354,10 @@ void* tscVgroupInfoClear(SVgroupsInfo *vgroupList) {
    return NULL;
  }
-  for(int32_t i = 0; i < vgroupList->numOfVgroups; ++i) {
-    SVgroupInfo* pVgroupInfo = &vgroupList->vgroups[i];
-    for(int32_t j = 0; j < pVgroupInfo->numOfEps; ++j) {
-      tfree(pVgroupInfo->epAddr[j].fqdn);
-    }
-    for(int32_t j = pVgroupInfo->numOfEps; j < TSDB_MAX_REPLICA; j++) {
-      assert( pVgroupInfo->epAddr[j].fqdn == NULL );
-    }
-  }
  tfree(vgroupList);
  return NULL;
 }
-void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src) {
-  dst->vgId = src->vgId;
-  dst->numOfEps = src->numOfEps;
-  for(int32_t i = 0; i < dst->numOfEps; ++i) {
-    tfree(dst->epAddr[i].fqdn);
-    dst->epAddr[i].port = src->epAddr[i].port;
-    assert(dst->epAddr[i].fqdn == NULL);
-    dst->epAddr[i].fqdn = strdup(src->epAddr[i].fqdn);
-  }
-}
 char* serializeTagData(STagData* pTagData, char* pMsg) {
  int32_t n = (int32_t) strlen(pTagData->name);
  *(int32_t*) pMsg = htonl(n);
@@ -4397,8 +4448,10 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
  size_t      sz   = 0;
  STableMeta* pChild = *ppChild;
  STableMeta* pChild1;
-  taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz);
+  if(NULL == taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz)) {
+    tfree(p); 
+  }
  // tableMeta exists, build child table meta according to the super table meta
  // the uid need to be checked in addition to the general name of the super table.
@@ -4408,9 +4461,9 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
    int32_t tableMetaSize =  sizeof(STableMeta)  + totalBytes;
    if (*tableMetaCapacity < tableMetaSize) {
      pChild1 = realloc(pChild, tableMetaSize);
-      if(pChild1 == NULL) 
+      if(pChild1 == NULL)
        return -1;
-      pChild = pChild1; 
+      pChild = pChild1;
      *tableMetaCapacity = (size_t)tableMetaSize;
    }
@@ -4449,7 +4502,7 @@ SVgroupsInfo* tscVgroupsInfoDup(SVgroupsInfo* pVgroupsInfo) {
  SVgroupsInfo* pInfo = calloc(1, size);
  pInfo->numOfVgroups = pVgroupsInfo->numOfVgroups;
  for (int32_t m = 0; m < pVgroupsInfo->numOfVgroups; ++m) {
-    tscSVgroupInfoCopy(&pInfo->vgroups[m], &pVgroupsInfo->vgroups[m]);
+    memcpy(&pInfo->vgroups[m], &pVgroupsInfo->vgroups[m], sizeof(SVgroupMsg));
  }
  return pInfo;
 }
@@ -4682,6 +4735,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  pQueryAttr->distinct          = pQueryInfo->distinct;
  pQueryAttr->sw                = pQueryInfo->sessionWindow;
  pQueryAttr->stateWindow       = pQueryInfo->stateWindow;
+  pQueryAttr->multigroupResult  = pQueryInfo->multigroupResult;
  pQueryAttr->numOfCols         = numOfCols;
  pQueryAttr->numOfOutput       = numOfOutput;
@@ -4756,7 +4810,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  }
  if (pQueryAttr->fillType != TSDB_FILL_NONE) {
-    pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
+    pQueryAttr->fillVal = calloc(pQueryInfo->numOfFillVal, sizeof(int64_t));
    memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
  }
@@ -4954,3 +5008,31 @@ void tscRemoveTableMetaBuf(STableMetaInfo* pTableMetaInfo, uint64_t id) {
  taosHashRemove(tscTableMetaMap, fname, len);
  tscDebug("0x%"PRIx64" remove table meta %s, numOfRemain:%d", id, fname, (int32_t) taosHashGetSize(tscTableMetaMap));
 }
+char* cloneCurrentDBName(SSqlObj* pSql) {
+  char        *p = NULL;
+  HttpContext *pCtx = NULL;
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
+  STscObj *pTscObj = pSql->pTscObj;
+  switch (pTscObj->from) {
+  case TAOS_REQ_FROM_HTTP:
+    pCtx = pSql->param;
+    if (pCtx && pCtx->db[0] != '\0') {
+      char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN] = {0};
+      int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
+      assert(len <= sizeof(db));
+      p = strdup(db);
+    }
+    break;
+  default:
+    break;
+  }
+  if (p == NULL) {
+    p = strdup(pSql->pTscObj->db);
+  }
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
+  return p;
+}
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -125,6 +125,7 @@ extern int32_t  tsHttpMaxThreads;
 extern int8_t   tsHttpEnableCompress;
 extern int8_t   tsHttpEnableRecordSql;
 extern int8_t   tsTelegrafUseFieldNum;
+extern int8_t   tsHttpDbNameMandatory;
 // mqtt
 extern int8_t tsEnableMqttModule;

--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -448,6 +448,7 @@ static void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols
  int dcol = 0;
  while (dcol < pCols->numOfCols) {
+    bool setCol = 0;
    SDataCol *pDataCol = &(pCols->cols[dcol]);
    if (rcol >= schemaNCols(pSchema)) {
      dataColAppendVal(pDataCol, getNullValue(pDataCol->type), pCols->numOfRows, pCols->maxPoints);
@@ -458,13 +459,14 @@ static void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols
    STColumn *pRowCol = schemaColAt(pSchema, rcol);
    if (pRowCol->colId == pDataCol->colId) {
      void *value = tdGetRowDataOfCol(row, pRowCol->type, pRowCol->offset + TD_DATA_ROW_HEAD_SIZE);
+      if(!isNull(value, pDataCol->type)) setCol = 1;
      dataColAppendVal(pDataCol, value, pCols->numOfRows, pCols->maxPoints);
      dcol++;
      rcol++;
    } else if (pRowCol->colId < pDataCol->colId) {
      rcol++;
    } else {
-      if(forceSetNull) {
+      if(forceSetNull || setCol) {
        dataColAppendVal(pDataCol, getNullValue(pDataCol->type), pCols->numOfRows, pCols->maxPoints);
      }
      dcol++;
@@ -482,6 +484,7 @@ static void tdAppendKvRowToDataCol(SKVRow row, STSchema *pSchema, SDataCols *pCo
  int nRowCols = kvRowNCols(row);
  while (dcol < pCols->numOfCols) {
+    bool setCol = 0;
    SDataCol *pDataCol = &(pCols->cols[dcol]);
    if (rcol >= nRowCols || rcol >= schemaNCols(pSchema)) {
      dataColAppendVal(pDataCol, getNullValue(pDataCol->type), pCols->numOfRows, pCols->maxPoints);
@@ -493,13 +496,14 @@ static void tdAppendKvRowToDataCol(SKVRow row, STSchema *pSchema, SDataCols *pCo
    if (colIdx->colId == pDataCol->colId) {
      void *value = tdGetKvRowDataOfCol(row, colIdx->offset);
+      if(!isNull(value, pDataCol->type)) setCol = 1;
      dataColAppendVal(pDataCol, value, pCols->numOfRows, pCols->maxPoints);
      ++dcol;
      ++rcol;
    } else if (colIdx->colId < pDataCol->colId) {
      ++rcol;
    } else {
-      if (forceSetNull) {
+      if (forceSetNull || setCol) {
        dataColAppendVal(pDataCol, getNullValue(pDataCol->type), pCols->numOfRows, pCols->maxPoints);
      }
      ++dcol;
@@ -533,7 +537,7 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *
    ASSERT(target->numOfRows + rowsToMerge <= target->maxPoints);
    for (int i = 0; i < rowsToMerge; i++) {
      for (int j = 0; j < source->numOfCols; j++) {
-        if (source->cols[j].len > 0) {
+        if (source->cols[j].len > 0 || target->cols[j].len > 0) {
          dataColAppendVal(target->cols + j, tdGetColDataOfRow(source->cols + j, i + (*pOffset)), target->numOfRows,
                           target->maxPoints);
        }
@@ -577,7 +581,7 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
    if (key1 < key2) {
      for (int i = 0; i < src1->numOfCols; i++) {
        ASSERT(target->cols[i].type == src1->cols[i].type);
-        if (src1->cols[i].len > 0) {
+        if (src1->cols[i].len > 0 || target->cols[i].len > 0) {
          dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src1->cols + i, *iter1), target->numOfRows,
                           target->maxPoints);
        }
@@ -595,6 +599,8 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
          } else if(!forceSetNull && key1 == key2 && src1->cols[i].len > 0) {
            dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src1->cols + i, *iter1), target->numOfRows,
                             target->maxPoints);
+          } else if(target->cols[i].len > 0) {
+            dataColSetNullAt(&target->cols[i], target->numOfRows);
          }
        }
        target->numOfRows++;

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -84,7 +84,7 @@ int8_t  tsTscEnableRecordSql = 0;
 // the maximum number of results for projection query on super table that are returned from
 // one virtual node, to order according to timestamp
-int32_t tsMaxNumOfOrderedResults = 100000;
+int32_t tsMaxNumOfOrderedResults = 1000000;
 // 10 ms for sliding time, the value will changed in case of time precision changed
 int32_t tsMinSlidingTime = 10;
@@ -165,6 +165,7 @@ int32_t  tsHttpMaxThreads = 2;
 int8_t   tsHttpEnableCompress = 1;
 int8_t   tsHttpEnableRecordSql = 0;
 int8_t   tsTelegrafUseFieldNum = 0;
+int8_t   tsHttpDbNameMandatory = 0;
 // mqtt
 int8_t tsEnableMqttModule = 0;  // not finished yet, not started it by default
@@ -1017,8 +1018,8 @@ static void doInitGlobalConfig(void) {
  cfg.ptr = &tsMaxNumOfOrderedResults;
  cfg.valType = TAOS_CFG_VTYPE_INT32;
  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MAX_SQL_LEN;
+  cfg.minValue = 100000;
-  cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
+  cfg.maxValue = 100000000;
  cfg.ptrLength = 0;
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
@@ -1217,10 +1218,10 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
-  cfg.option = "topicBianryLen";
+  cfg.option = "topicBinaryLen";
  cfg.ptr = &tsTopicBianryLen;
  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
  cfg.minValue = 16;
  cfg.maxValue = 16000;
  cfg.ptrLength = 0;
@@ -1267,6 +1268,16 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
+  cfg.option = "httpDbNameMandatory";
+  cfg.ptr = &tsHttpDbNameMandatory;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
  // debug flag
  cfg.option = "numOfLogLines";
  cfg.ptr = &tsNumOfLogLines;
@@ -1570,7 +1581,6 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
-  assert(tsGlobalConfigNum <= TSDB_CFG_MAX_NUM);
 #ifdef TD_TSZ
  // lossy compress
  cfg.option = "lossyColumns";
@@ -1591,8 +1601,6 @@ static void doInitGlobalConfig(void) {
  cfg.maxValue = MAX_FLOAT;
  cfg.ptrLength = 0;
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
  cfg.option = "dPrecision";
@@ -1624,6 +1632,9 @@ static void doInitGlobalConfig(void) {
  cfg.ptrLength = 0;
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
+  assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM);
+#else
+  assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM - 5);
 #endif
 }

--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -31,12 +31,12 @@ void tVariantCreate(tVariant *pVar, SStrToken *token) {
  switch (token->type) {
    case TSDB_DATA_TYPE_BOOL: {
-      int32_t k = strncasecmp(token->z, "true", 4);
+      if (strncasecmp(token->z, "true", 4) == 0) {
-      if (k == 0) {
        pVar->i64 = TSDB_TRUE;
-      } else {
+      } else if (strncasecmp(token->z, "false", 5) == 0) {
-        assert(strncasecmp(token->z, "false", 5) == 0);
        pVar->i64 = TSDB_FALSE;
+      } else {
+        return;
      }
      break;

--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -117,7 +117,6 @@
                        <exclude>**/DatetimeBefore1970Test.java</exclude>
                        <exclude>**/FailOverTest.java</exclude>
                        <exclude>**/InvalidResultSetPointerTest.java</exclude>
-                        <exclude>**/RestfulConnectionTest.java</exclude>
                        <exclude>**/TSDBJNIConnectorTest.java</exclude>
                        <exclude>**/TaosInfoMonitorTest.java</exclude>
                        <exclude>**/UnsignedNumberJniTest.java</exclude>

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.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/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
--- a/src/connector/python/README.md
+++ b/src/connector/python/README.md
--- a/src/connector/python/examples/bind-multi.py
+++ b/src/connector/python/examples/bind-multi.py
--- a/src/connector/python/examples/bind-row.py
+++ b/src/connector/python/examples/bind-row.py
--- a/src/connector/python/examples/demo.py
+++ b/src/connector/python/examples/demo.py
--- a/src/connector/python/examples/insert-lines.py
+++ b/src/connector/python/examples/insert-lines.py
--- a/src/connector/python/examples/pep-249.py
+++ b/src/connector/python/examples/pep-249.py
--- a/src/connector/python/examples/query-async.py
+++ b/src/connector/python/examples/query-async.py
--- a/src/connector/python/examples/query-objectively.py
+++ b/src/connector/python/examples/query-objectively.py
--- a/src/connector/python/examples/subscribe-async.py
+++ b/src/connector/python/examples/subscribe-async.py
--- a/src/connector/python/examples/subscribe-sync.py
+++ b/src/connector/python/examples/subscribe-sync.py
--- a/src/connector/python/pyproject.toml
+++ b/src/connector/python/pyproject.toml
--- a/src/connector/python/setup.py
+++ b/src/connector/python/setup.py
--- a/src/connector/python/taos/__init__.py
+++ b/src/connector/python/taos/__init__.py
--- a/src/connector/python/taos/bind.py
+++ b/src/connector/python/taos/bind.py
--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
--- a/src/connector/python/taos/connection.py
+++ b/src/connector/python/taos/connection.py
--- a/src/connector/python/taos/constants.py
+++ b/src/connector/python/taos/constants.py
--- a/src/connector/python/taos/cursor.py
+++ b/src/connector/python/taos/cursor.py
--- a/src/connector/python/taos/dbapi.py
+++ b/src/connector/python/taos/dbapi.py
--- a/src/connector/python/taos/error.py
+++ b/src/connector/python/taos/error.py
--- a/src/connector/python/taos/field.py
+++ b/src/connector/python/taos/field.py
--- a/src/connector/python/taos/precision.py
+++ b/src/connector/python/taos/precision.py
--- a/src/connector/python/taos/result.py
+++ b/src/connector/python/taos/result.py
--- a/src/connector/python/taos/statement.py
+++ b/src/connector/python/taos/statement.py
--- a/src/connector/python/taos/stream.py
+++ b/src/connector/python/taos/stream.py
--- a/src/connector/python/taos/subscription.py
+++ b/src/connector/python/taos/subscription.py
--- a/src/connector/python/taos/timestamp.py
+++ b/src/connector/python/taos/timestamp.py
--- a/src/connector/python/tests/test-td6231.py
+++ b/src/connector/python/tests/test-td6231.py
--- a/src/connector/python/tests/test_ctaos.py
+++ b/src/connector/python/tests/test_ctaos.py
--- a/src/connector/python/tests/test_info.py
+++ b/src/connector/python/tests/test_info.py
--- a/src/connector/python/tests/test_lines.py
+++ b/src/connector/python/tests/test_lines.py
--- a/src/connector/python/tests/test_query.py
+++ b/src/connector/python/tests/test_query.py
--- a/src/connector/python/tests/test_query_a.py
+++ b/src/connector/python/tests/test_query_a.py
--- a/src/connector/python/tests/test_stmt.py
+++ b/src/connector/python/tests/test_stmt.py
--- a/src/connector/python/tests/test_stream.py
+++ b/src/connector/python/tests/test_stream.py
--- a/src/connector/python/tests/test_subscribe.py
+++ b/src/connector/python/tests/test_subscribe.py
--- 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/ttokendef.h
+++ b/src/inc/ttokendef.h
--- 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/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/kit/taospack/taospack.c
+++ b/src/kit/taospack/taospack.c
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/os/src/darwin/darwinSystem.c
+++ b/src/os/src/darwin/darwinSystem.c
--- a/src/os/src/linux/linuxEnv.c
+++ b/src/os/src/linux/linuxEnv.c
--- a/src/os/src/linux/osSystem.c
+++ b/src/os/src/linux/osSystem.c
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
--- a/src/plugins/http/inc/httpRestHandle.h
+++ b/src/plugins/http/inc/httpRestHandle.h
--- a/src/plugins/http/inc/httpUtil.h
+++ b/src/plugins/http/inc/httpUtil.h
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
--- a/src/plugins/http/src/httpHandle.c
+++ b/src/plugins/http/src/httpHandle.c
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
--- a/src/plugins/http/src/httpResp.c
+++ b/src/plugins/http/src/httpResp.c
--- a/src/plugins/http/src/httpRestHandle.c
+++ b/src/plugins/http/src/httpRestHandle.c
--- a/src/plugins/http/src/httpRestJson.c
+++ b/src/plugins/http/src/httpRestJson.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/httpUtil.c
+++ b/src/plugins/http/src/httpUtil.c
--- a/src/plugins/monitor/src/monMain.c
+++ b/src/plugins/monitor/src/monMain.c
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
--- a/src/query/inc/qTableMeta.h
+++ b/src/query/inc/qTableMeta.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.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/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
--- a/src/util/inc/tconfig.h
+++ b/src/util/inc/tconfig.h
--- a/src/util/inc/tnettest.h
+++ b/src/util/inc/tnettest.h
--- a/src/util/inc/tstrbuild.h
+++ b/src/util/inc/tstrbuild.h
--- a/src/util/inc/tutil.h
+++ b/src/util/inc/tutil.h
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.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/terror.c
+++ b/src/util/src/terror.c
--- a/src/util/src/tlosertree.c
+++ b/src/util/src/tlosertree.c
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
--- a/src/util/src/tref.c
+++ b/src/util/src/tref.c
--- a/src/util/src/tsocket.c
+++ b/src/util/src/tsocket.c
--- a/src/util/src/tstrbuild.c
+++ b/src/util/src/tstrbuild.c
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/tests/examples/JDBC/JDBCDemo/pom.xml
+++ b/tests/examples/JDBC/JDBCDemo/pom.xml
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcDemo.java
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcRestfulDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcRestfulDemo.java
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/SubscribeDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/SubscribeDemo.java
--- a/tests/examples/JDBC/springbootdemo/pom.xml
+++ b/tests/examples/JDBC/springbootdemo/pom.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/util/TaosAspect.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/util/TaosAspect.java
--- a/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
+++ b/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
--- 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/c/epoll.c
+++ b/tests/examples/c/epoll.c
--- a/tests/examples/c/makefile
+++ b/tests/examples/c/makefile
--- a/tests/examples/c/prepare.c
+++ b/tests/examples/c/prepare.c
--- a/tests/examples/c/schemaless.c
+++ b/tests/examples/c/schemaless.c
--- a/tests/examples/c/stream.c
+++ b/tests/examples/c/stream.c
--- a/tests/examples/c/subscribe.c
+++ b/tests/examples/c/subscribe.c
--- a/tests/gotest/batchtest.sh
+++ b/tests/gotest/batchtest.sh
--- a/tests/gotest/case001/case001.go
+++ b/tests/gotest/case001/case001.go
--- a/tests/gotest/case002/case002.bat
+++ b/tests/gotest/case002/case002.bat
--- a/tests/gotest/case002/case002.go
+++ b/tests/gotest/case002/case002.go
--- a/tests/gotest/case002/case002.sh
+++ b/tests/gotest/case002/case002.sh
--- a/tests/nettest/FQDNnettest.sh
+++ b/tests/nettest/FQDNnettest.sh
--- a/tests/nettest/TCPUDP.sh
+++ b/tests/nettest/TCPUDP.sh
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
--- a/tests/pytest/alter/alter_table.py
+++ b/tests/pytest/alter/alter_table.py
--- a/tests/pytest/client/version.py
+++ b/tests/pytest/client/version.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/functions/function_bottom.py
+++ b/tests/pytest/functions/function_bottom.py
--- a/tests/pytest/functions/function_derivative.py
+++ b/tests/pytest/functions/function_derivative.py
--- a/tests/pytest/functions/function_diff.py
+++ b/tests/pytest/functions/function_diff.py
--- a/tests/pytest/functions/function_interp.py
+++ b/tests/pytest/functions/function_interp.py
--- a/tests/pytest/functions/function_top.py
+++ b/tests/pytest/functions/function_top.py
--- a/tests/pytest/functions/queryTestCases.py
+++ b/tests/pytest/functions/queryTestCases.py
--- a/tests/pytest/functions/showOfflineThresholdIs864000.py
+++ b/tests/pytest/functions/showOfflineThresholdIs864000.py
--- a/tests/pytest/import_merge/import_update_0.py
+++ b/tests/pytest/import_merge/import_update_0.py
--- a/tests/pytest/import_merge/import_update_1.py
+++ b/tests/pytest/import_merge/import_update_1.py
--- a/tests/pytest/import_merge/import_update_2.py
+++ b/tests/pytest/import_merge/import_update_2.py
--- a/tests/pytest/insert/insertFromCSVPerformance.py
+++ b/tests/pytest/insert/insertFromCSVPerformance.py
--- a/tests/pytest/insert/line_insert.py
+++ b/tests/pytest/insert/line_insert.py
--- a/tests/pytest/insert/schemalessInsert.py
+++ b/tests/pytest/insert/schemalessInsert.py
--- a/tests/pytest/insert/specialSql.py
+++ b/tests/pytest/insert/specialSql.py
--- a/tests/pytest/insert/verifyMemToDiskCrash.py
+++ b/tests/pytest/insert/verifyMemToDiskCrash.py
--- a/tests/pytest/query/filterNoKeyword.py
+++ b/tests/pytest/query/filterNoKeyword.py
--- a/tests/pytest/query/last_row_cache.py
+++ b/tests/pytest/query/last_row_cache.py
--- a/tests/pytest/query/nestedQuery/nestedQuery.py
+++ b/tests/pytest/query/nestedQuery/nestedQuery.py
--- a/tests/pytest/query/nestquery_last_row.py
+++ b/tests/pytest/query/nestquery_last_row.py
--- a/tests/pytest/query/operator_cost.py
+++ b/tests/pytest/query/operator_cost.py
--- a/tests/pytest/query/query.py
+++ b/tests/pytest/query/query.py
--- a/tests/pytest/query/queryDiffColsOr.py
+++ b/tests/pytest/query/queryDiffColsOr.py
--- a/tests/pytest/query/queryGroupTbname.py
+++ b/tests/pytest/query/queryGroupTbname.py
--- a/tests/pytest/query/queryJoin.py
+++ b/tests/pytest/query/queryJoin.py
--- a/tests/pytest/query/queryPerformance.py
+++ b/tests/pytest/query/queryPerformance.py
--- a/tests/pytest/query/udf.py
+++ b/tests/pytest/query/udf.py
--- a/tests/pytest/restful/restful_bind_db1.py
+++ b/tests/pytest/restful/restful_bind_db1.py
--- a/tests/pytest/restful/restful_bind_db2.py
+++ b/tests/pytest/restful/restful_bind_db2.py
--- a/tests/pytest/tools/schemalessInsertPerformance.py
+++ b/tests/pytest/tools/schemalessInsertPerformance.py
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.json
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insert4096columns_not_use_taosdemo.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insert4096columns_not_use_taosdemo.py
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.json
--- a/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
--- a/tests/pytest/tools/taosdemoTest.py
+++ b/tests/pytest/tools/taosdemoTest.py
--- a/tests/pytest/tools/taosdemoTestTblAlt.py
+++ b/tests/pytest/tools/taosdemoTestTblAlt.py
--- a/tests/pytest/tools/taosdumpTest2.py
+++ b/tests/pytest/tools/taosdumpTest2.py
--- a/tests/pytest/tools/taosdumpTestNanoSupport.py
+++ b/tests/pytest/tools/taosdumpTestNanoSupport.py
--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.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/util/sub.py
+++ b/tests/pytest/util/sub.py
--- a/tests/script/api/makefile
+++ b/tests/script/api/makefile
--- a/tests/script/api/stmt.c
+++ b/tests/script/api/stmt.c
--- a/tests/script/fullGeneralSuite.sim
+++ b/tests/script/fullGeneralSuite.sim
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
--- a/tests/script/general/parser/interp_blocks.sim
+++ b/tests/script/general/parser/interp_blocks.sim
--- a/tests/script/general/parser/interp_test.sim
+++ b/tests/script/general/parser/interp_test.sim
--- a/tests/test-all.sh
+++ b/tests/test-all.sh