Merge branch 'develop' into feature/TD-1925

dd459c53 · Hongze Cheng · 9598664f · 0f1d6ee6 · dd459c53 · dd459c53
249 changed file
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -3,6 +3,7 @@ os: Visual Studio 2015
 environment:
  matrix:
    - ARCH: amd64
+    - ARCH: x86
 clone_folder: c:\dev\TDengine
 clone_depth: 1
@@ -23,6 +24,7 @@ notifications:
 - provider: Email
  to:
  - sangshuduo@gmail.com
  on_build_success: true
  on_build_failure: true
  on_build_status_changed: true
--- a/Jenkinsfile
+++ b/Jenkinsfile
+import hudson.model.Result
+import jenkins.model.CauseOfInterruption
+properties([pipelineTriggers([githubPush()])])
+node {
+    git url: 'https://github.com/taosdata/TDengine.git'
+}
+def abortPreviousBuilds() {
+  def currentJobName = env.JOB_NAME
+  def currentBuildNumber = env.BUILD_NUMBER.toInteger()
+  def jobs = Jenkins.instance.getItemByFullName(currentJobName)
+  def builds = jobs.getBuilds()
+  for (build in builds) {
+    if (!build.isBuilding()) {
+      continue;
+    }
+    if (currentBuildNumber == build.getNumber().toInteger()) {
+      continue;
+    }
+    build.doKill()    //doTerm(),doKill(),doTerm()
+  }
+}
+//abort previous build
+abortPreviousBuilds()
+def abort_previous(){
+  def buildNumber = env.BUILD_NUMBER as int
+  if (buildNumber > 1) milestone(buildNumber - 1)
+  milestone(buildNumber)
+}
+def pre_test(){
+    catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                sudo rmtaos
+                '''
+    }
+    sh '''
+    cd ${WKC}
+    rm -rf *
+    cd ${WK}
+    git reset --hard
+    git checkout develop
+    git pull
+    cd ${WKC}
+    rm -rf *
+    mv ${WORKSPACE}/* .
+    cd ${WK}
+    export TZ=Asia/Harbin
+    date
+    rm -rf ${WK}/debug
+    mkdir debug
+    cd debug
+    cmake .. > /dev/null
+    make > /dev/null
+    make install > /dev/null
+    cd ${WKC}/tests
+    '''
+    return 1
+}
 pipeline {
  agent none
  environment{
      WK = '/var/lib/jenkins/workspace/TDinternal'
      WKC= '/var/lib/jenkins/workspace/TDinternal/community'
  }
  stages {
      stage('Parallel test stage') {
+        //only build pr
+        when {
+              changeRequest()
+          }
      parallel {
-        stage('pytest') {
+        stage('python') {
-          agent{label '184'}
+          agent{label 'pytest'}
          steps {
+            pre_test()
            sh '''
-            date
-            cd ${WKC}
-            git reset --hard
-            git checkout develop
-            git pull
-            git submodule update
-            cd ${WK}
-            git reset --hard
-            git checkout develop
-            git pull
-            export TZ=Asia/Harbin
-            date
-            rm -rf ${WK}/debug
-            mkdir debug
-            cd debug
-            cmake .. > /dev/null
-            make > /dev/null
-            make install > /dev/null
            cd ${WKC}/tests
-            #./test-all.sh smoke
            ./test-all.sh pytest
            date'''
          }
        }
        stage('test_b1') {
-          agent{label 'master'}
+          agent{label 'b1'}
-          steps {
+          steps {            
+            pre_test()
            sh '''
-            cd ${WKC}
-            git reset --hard
-            git checkout develop
-            git pull
-            git submodule update
-            cd ${WK}
-            git reset --hard
-            git checkout develop
-            git pull
-            export TZ=Asia/Harbin
-            date
-            rm -rf ${WK}/debug
-            mkdir debug
-            cd debug
-            cmake .. > /dev/null
-            make > /dev/null
            cd ${WKC}/tests
-            #./test-all.sh smoke
            ./test-all.sh b1
            date'''
          }
        }
        stage('test_crash_gen') {
-          agent{label "185"}
+          agent{label "b2"}
          steps {
-            sh '''
+            pre_test()
-            cd ${WKC}
-            git reset --hard
-            git checkout develop
-            git pull
-            git submodule update
-            cd ${WK}
-            git reset --hard
-            git checkout develop
-            git pull
-            export TZ=Asia/Harbin
-            rm -rf ${WK}/debug
-            mkdir debug
-            cd debug
-            cmake .. > /dev/null
-            make > /dev/null
-            cd ${WKC}/tests/pytest
-            '''
            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                sh '''
                cd ${WKC}/tests/pytest
@@ -109,193 +126,28 @@ pipeline {
        }
        stage('test_valgrind') {
-          agent{label "186"}
+          agent{label "b3"}
          steps {
+            pre_test()
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                ./valgrind-test.sh 2>&1 > mem-error-out.log
+                ./handle_val_log.sh
+                '''
+            }           
            sh '''
-            cd ${WKC}
-            git reset --hard
-            git checkout develop
-            git pull
-            git submodule update
-            cd ${WK}
-            git reset --hard
-            git checkout develop
-            git pull
-            export TZ=Asia/Harbin
-            date
-            rm -rf ${WK}/debug
-            mkdir debug
-            cd debug
-            cmake .. > /dev/null
-            make > /dev/null
-            cd ${WKC}/tests/pytest
-            ./valgrind-test.sh 2>&1 > mem-error-out.log
-            ./handle_val_log.sh
            date
            cd ${WKC}/tests
            ./test-all.sh b3
            date'''
          }
        }
-       stage('connector'){
-         agent{label "release"}
-         steps{
-            sh'''
-            cd ${WORKSPACE}
-            git checkout develop
-            '''
-            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                sh '''
-                cd ${WORKSPACE}/tests/gotest
-                bash batchtest.sh
-                '''
-            }
-            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                sh '''
-                cd ${WORKSPACE}/tests/examples/python/PYTHONConnectorChecker
-                python3 PythonChecker.py
-                '''
-            }
-            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                sh '''
-                cd ${WORKSPACE}/tests/examples/JDBC/JDBCDemo/
-                mvn clean package assembly:single >/dev/null 
-                java -jar target/jdbcChecker-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
-                '''
-            }
-            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                sh '''
-                cd ${JENKINS_HOME}/workspace/C#NET/src/CheckC#
-                dotnet run
-                '''
-            }
-         }
-       }
-       stage('arm64_build'){
-                agent{label 'arm64'}
-                steps{
-                    sh '''
-                    cd ${WK}
-                    git fetch
-                    git checkout develop
-                    git pull
-                    cd ${WKC}
-                    git fetch
-                    git checkout develop
-                    git pull
-                    git submodule update                    
-                    cd ${WKC}/packaging
-                    ./release.sh -v cluster -c aarch64 -n 2.0.0.0 -m 2.0.0.0
-                    '''
-                }
-            }
-            stage('arm32_build'){
-                agent{label 'arm32'}
-                steps{
-                    catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                        sh '''
-                        cd ${WK}
-                        git fetch
-                        git checkout develop
-                        git pull
-                        cd ${WKC}
-                        git fetch
-                        git checkout develop
-                        git pull
-                        git submodule update
-                        cd ${WKC}/packaging
-                        ./release.sh -v cluster -c aarch32 -n 2.0.0.0 -m 2.0.0.0
-                        '''
-                    }
-                }
-            }
-      }
    }
  }
-  post {             
+  }
-        success {
-            emailext (
+}
-                subject: "SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
-                body: '''<!DOCTYPE html>
-                <html>
-                <head>
-                <meta charset="UTF-8">
-                </head>
-                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
-                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
-                        <tr>
-                            <td><br />
-                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
-                                <hr size="2" width="100%" align="center" /></td>
-                        </tr>
-                        <tr>
-                            <td>
-                                <ul>
-                                <div style="font-size:18px">
-                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
-                                    <li>构建结果：<span style="color:green"> Successful </span></li>
-                                    <li>构建编号：${BUILD_NUMBER}</li>
-                                    <li>触发用户：${CAUSE}</li>
-                                    <li>变更概要：${CHANGES}</li>
-                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
-                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
-                                    <li>变更集：${JELLY_SCRIPT}</li>
-                                </div>
-                                </ul>
-                            </td>
-                        </tr>
-                    </table></font>
-                </body>
-                </html>''',
-                to: "yqliu@taosdata.com,pxiao@taosdata.com",
-                from: "support@taosdata.com"
-            )
-        }
-        failure {
-            emailext (
-                subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
-                body: '''<!DOCTYPE html>
-                <html>
-                <head>
-                <meta charset="UTF-8">
-                </head>
-                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
-                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
-                        <tr>
-                            <td><br />
-                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
-                                <hr size="2" width="100%" align="center" /></td>
-                        </tr>
-                        <tr>
-                            <td>
-                                <ul>
-                                <div style="font-size:18px">
-                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
-                                    <li>构建结果：<span style="color:green"> Successful </span></li>
-                                    <li>构建编号：${BUILD_NUMBER}</li>
-                                    <li>触发用户：${CAUSE}</li>
-                                    <li>变更概要：${CHANGES}</li>
-                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
-                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
-                                    <li>变更集：${JELLY_SCRIPT}</li>
-                                </div>
-                                </ul>
-                            </td>
-                        </tr>
-                    </table></font>
-                </body>
-                </html>''',
-                to: "yqliu@taosdata.com,pxiao@taosdata.com",
-                from: "support@taosdata.com"
-            )
-        }
-    }
-}
\ No newline at end of file
--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -49,7 +49,7 @@ IF (TD_LINUX_64)
  ADD_DEFINITIONS(-D_M_X64)
  ADD_DEFINITIONS(-D_TD_LINUX_64)
  MESSAGE(STATUS "linux64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
  ADD_DEFINITIONS(-DUSE_LIBICONV)
 ENDIF ()
@@ -57,7 +57,7 @@ IF (TD_LINUX_32)
  ADD_DEFINITIONS(-D_TD_LINUX_32)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "linux32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 IF (TD_ARM_64)
@@ -66,7 +66,7 @@ IF (TD_ARM_64)
  ADD_DEFINITIONS(-D_TD_ARM_)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "arm64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 IF (TD_ARM_32)
@@ -74,21 +74,21 @@ IF (TD_ARM_32)
  ADD_DEFINITIONS(-D_TD_ARM_)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "arm32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
 ENDIF ()
 IF (TD_MIPS_64)
  ADD_DEFINITIONS(-D_TD_MIPS_64_)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "mips64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 IF (TD_MIPS_32)
  ADD_DEFINITIONS(-D_TD_MIPS_32_)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "mips32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 IF (TD_APLHINE)
@@ -109,8 +109,8 @@ IF (TD_LINUX)
    MESSAGE(STATUS "set ningsi macro to true")
  ENDIF ()
-  SET(DEBUG_FLAGS "-O0 -DDEBUG")
+  SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
-  SET(RELEASE_FLAGS "-O0 -Wno-unused-variable -Wunused-but-set-variable")
+  SET(RELEASE_FLAGS "-O3 -Wno-error")
  IF (${COVER} MATCHES "true")
    MESSAGE(STATUS "Test coverage mode, add extra flags")
@@ -129,9 +129,9 @@ IF (TD_DARWIN_64)
  ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "darwin64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -g -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
-  SET(DEBUG_FLAGS "-O0 -DDEBUG")
+  SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
-  SET(RELEASE_FLAGS "-O0")
+  SET(RELEASE_FLAGS "-Og")
 ENDIF ()
 IF (TD_WINDOWS)
@@ -144,7 +144,7 @@ IF (TD_WINDOWS)
  IF (NOT TD_GODLL)
    SET(COMMON_FLAGS "/nologo /WX /wd4018 /wd2220 /Oi /Oy- /Gm- /EHsc /MT /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Gd /errorReport:prompt /analyze-")
    SET(DEBUG_FLAGS "/Zi /W3 /GL")
-    SET(RELEASE_FLAGS "/W0 /GL")
+    SET(RELEASE_FLAGS "/W0 /O3 /GL")
  ENDIF ()
  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/pthread)

--- a/cmake/env.inc
+++ b/cmake/env.inc
@@ -41,8 +41,10 @@ SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${COMMON_FLAGS} ${RELEASE_FL
 # SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${COMMON_CXX_FLAGS} ${RELEASE_FLAGS}")
 IF (${CMAKE_BUILD_TYPE} MATCHES "Debug")
+  SET(CMAKE_BUILD_TYPE "Debug")
  MESSAGE(STATUS "Build Debug Version")
 ELSEIF (${CMAKE_BUILD_TYPE} MATCHES "Release")
+  SET(CMAKE_BUILD_TYPE "Release")
  MESSAGE(STATUS "Build Release Version")
 ELSE ()
  IF (TD_WINDOWS)

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

--- a/documentation20/webdocs/assets/connector.png
+++ b/documentation20/webdocs/assets/connector.png
--- a/documentation20/webdocs/markdowndocs/Documentation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Documentation-ch.md
@@ -84,6 +84,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 - [数据导出](https://www.taosdata.com/cn/documentation20/administrator/#数据导出)：从shell按表导出，也可用taosdump工具做各种导出
 - [系统监控](https://www.taosdata.com/cn/documentation20/administrator/#系统监控)：检查系统现有的连接、查询、流式计算，日志和事件等
 - [文件目录结构](https://www.taosdata.com/cn/documentation20/administrator/#文件目录结构)：TDengine数据文件、配置文件等所在目录
+- [参数限制和保留关键字](https://www.taosdata.com/cn/documentation20/administrator/#参数限制和保留关键字)：TDengine的参数限制和保留关键字列表
 ## [TAOS SQL](https://www.taosdata.com/cn/documentation20/taos-sql)
@@ -128,4 +129,4 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 ## [培训和FAQ](https://www.taosdata.com/cn/faq)
 - [FAQ](https://www.taosdata.com/cn/documentation20/faq)：常见问题与答案
 - [应用案列](https://www.taosdata.com/cn/blog/?categories=4)：一些使用实例来解释如何使用TDengine
\ No newline at end of file
--- a/documentation20/webdocs/markdowndocs/Evaluation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Evaluation-ch.md
@@ -59,5 +59,3 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 |要求运维学习成本可控|  |  | √ |同上。|
 |要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
-## TDengine 性能指标介绍和验证方法
--- a/documentation20/webdocs/markdowndocs/Getting Started-ch.md
+++ b/documentation20/webdocs/markdowndocs/Getting Started-ch.md
@@ -2,7 +2,7 @@
 ## 快捷安装
-TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版仅能在Linux系统上安装和运行，后续会支持Windows、MAC OS等系统。如果应用需要在Windows或Mac上运行，目前只能使用TDengine的RESTful接口连接服务器。硬件支持X64，后续会支持ARM、龙芯等CPU系统。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。
+TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、mac OS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。
 ### 通过源码安装
@@ -14,29 +14,11 @@ TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版
 ### 通过安装包安装
-服务器部分，我们提供三种安装包，您可以根据需要选择。TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。
+TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。服务端安装包包含客户端和连接器，我们提供三种安装包，您可以根据需要选择：
-<ul id='packageList'>
+- TDengine-server-2.0.10.0-Linux-x64.rpm (4.2M)
-<li><a id='tdengine-rpm' style='color:var(--b2)'>TDengine-server-2.0.0.0-Linux-x64.rpm (5.3M)</a></li>
+- TDengine-server-2.0.10.0-Linux-x64.deb (2.7M)
-<li><a id='tdengine-deb' style='color:var(--b2)'>TDengine-server-2.0.0.0-Linux-x64.deb (2.5M)</a></li>
+- TDengine-server-2.0.10.0-Linux-x64.tar.gz (4.5M)
-<li><a id='tdengine-tar' style='color:var(--b2)'>TDengine-server-2.0.0.0-Linux-x64.tar.gz (5.3M)</a></li>
-</ul>
-客户端部分，Linux安装包如下：
- TDengine-client-2.0.0.0-Linux-x64.tar.gz (3.4M)
-报警模块的Linux安装包如下（请参考[报警模块的使用方法](https://github.com/taosdata/TDengine/blob/master/alert/README_cn.md)）：
- TDengine-alert-2.0.0-Linux-x64.tar.gz (8.1M)
-目前，TDengine只支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装。其他linux系统的支持正在开发中。用`which systemctl`命令来检测系统中是否存在`systemd`包:
-```cmd
-which systemctl
-```
-如果系统中不存在`systemd`包，请考虑[通过源码安装](#通过源码安装)TDengine。
 具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>。
@@ -44,28 +26,39 @@ which systemctl
 安装成功后，用户可使用`systemctl`命令来启动TDengine的服务进程。
-```cmd
+```bash
-systemctl start taosd
+$ systemctl start taosd
 ```
 检查服务是否正常工作。
-```cmd
+```bash
-systemctl status taosd
+$ systemctl status taosd
 ```
 如果TDengine服务正常工作，那么您可以通过TDengine的命令行程序`taos`来访问并体验TDengine。  
 **注意：**  
 - systemctl命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo
 - 为更好的获得产品反馈，改善产品，TDengine会采集基本的使用信息，但您可以修改系统配置文件taos.cfg里的配置参数telemetryReporting, 将其设为0，就可将其关闭。
+- TDengine采用FQDN(一般就是hostname)作为节点的ID，为保证正常运行，需要给运行taosd的服务器配置好hostname，在客户端应用运行的机器配置好DNS服务或hosts文件，保证FQDN能够解析。
+* TDengine 支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装，用`which systemctl`命令来检测系统中是否存在`systemd`包:
+  ```bash
+  $ which systemctl
+  ```
+  如果系统中不支持systemd，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
 ## TDengine命令行程序
 执行TDengine命令行程序，您只要在Linux终端执行`taos`即可。
-```cmd
+```bash
-taos
+$ taos
 ```
 如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
@@ -105,15 +98,15 @@ Query OK, 2 row(s) in set (0.001700s)
 示例：
-```cmd
+```bash
-taos -h 192.168.0.1 -s "use db; show tables;"
+$ taos -h 192.168.0.1 -s "use db; show tables;"
 ```
 ### 运行SQL命令脚本
 TDengine终端可以通过`source`命令来运行SQL命令脚本.
-```
+```mysql
 taos> source <filename>;
 ```
@@ -128,8 +121,8 @@ taos> source <filename>;
 启动TDengine的服务，在Linux终端执行taosdemo
-```
+```bash
-> taosdemo
+$ taosdemo
 ```
 该命令将在数据库test下面自动创建一张超级表meters，该超级表下有1万张表，表名为"t0" 到"t9999"，每张表有10万条记录，每条记录有 （f1, f2， f3）三个字段，时间戳从"2017-07-14 10:40:00 000" 到"2017-07-14 10:41:39 999"，每张表带有标签areaid和loc, areaid被设置为1到10, loc被设置为"beijing"或者“shanghai"。
@@ -140,33 +133,92 @@ taos> source <filename>;
 - 查询超级表下记录总条数：
-```
+```mysql
-taos>select count(*) from test.meters;
+taos> select count(*) from test.meters;
 ```
 - 查询10亿条记录的平均值、最大值、最小值等：
-```
+```mysql
-taos>select avg(f1), max(f2), min(f3) from test.meters;
+taos> select avg(f1), max(f2), min(f3) from test.meters;
 ```
 - 查询loc="beijing"的记录总条数：
-```
+```mysql
-taos>select count(*) from test.meters where loc="beijing";
+taos> select count(*) from test.meters where loc="beijing";
 ```
 - 查询areaid=10的所有记录的平均值、最大值、最小值等：
-```
+```mysql
-taos>select avg(f1), max(f2), min(f3) from test.meters where areaid=10;
+taos> select avg(f1), max(f2), min(f3) from test.meters where areaid=10;
 ```
 - 对表t10按10s进行平均值、最大值和最小值聚合统计：
-```
+```mysql
-taos>select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
+taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 ```
 **Note:** taosdemo命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help`详细列出。您可以设置不同参数进行体验。
+## 客户端和报警模块
+如果客户端和服务端运行在不同的电脑上，可以单独安装客户端。Linux和Windows安装包如下：
+- TDengine-client-2.0.10.0-Linux-x64.tar.gz(3.0M)
+- TDengine-client-2.0.10.0-Windows-x64.exe(2.8M)
+- TDengine-client-2.0.10.0-Windows-x86.exe(2.8M)
+报警模块的Linux安装包如下（请参考[报警模块的使用方法](https://github.com/taosdata/TDengine/blob/master/alert/README_cn.md)）：
+- TDengine-alert-2.0.10.0-Linux-x64.tar.gz (8.1M)
+## **支持平台列表**
+### TDengine服务器支持的平台列表
+|                | **CentOS**  **6/7/8** | **Ubuntu**  **16/18/20** | **Other Linux** | **统信****UOS** | **银河****/****中标麒麟** | **凝思**  **V60/V80** |
+| -------------- | --------------------- | ------------------------ | --------------- | --------------- | ------------------------- | --------------------- |
+| X64            | ●                     | ●                        |                 | ○               | ●                         | ●                     |
+| 树莓派ARM32    |                       | ●                        | ●               |                 |                           |                       |
+| 龙芯MIPS64     |                       |                          | ●               |                 |                           |                       |
+| 鲲鹏  ARM64    |                       | ○                        | ○               |                 | ●                         |                       |
+| 申威  Alpha64  |                       |                          | ○               | ●               |                           |                       |
+| 飞腾ARM64      |                       | ○优麒麟                  |                 |                 |                           |                       |
+| 海光X64        | ●                     | ●                        | ●               | ○               | ●                         | ●                     |
+| 瑞芯微ARM64/32 |                       |                          | ○               |                 |                           |                       |
+| 全志ARM64/32   |                       |                          | ○               |                 |                           |                       |
+| 炬力ARM64/32   |                       |                          | ○               |                 |                           |                       |
+| TI ARM32       |                       |                          | ○               |                 |                           |                       |
+注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
+### TDengine客户端和连接器支持的平台列表
+目前TDengine的连接器可支持的平台广泛，目前包括：X64/X86/ARM64/ARM32/MIPS/Alpha等硬件平台，以及Linux/Win64/Win32等开发环境。
+对照矩阵如下：
+| **CPU**     | **X64   64bit** |           |           | **X86   32bit** | **ARM64** | **ARM32** | **MIPS **  **龙芯** | **Alpha **  **申威** | **X64 **  **海光** |
+| ----------- | --------------- | --------- | --------- | --------------- | --------- | --------- | ------------------- | -------------------- | ------------------ |
+| **OS**      | **Linux**       | **Win64** | **Win32** | **Win32**       | **Linux** | **Linux** | **Linux**           | **Linux**            | **Linux**          |
+| **C/C++**   | ●               | ●         | ●         | ○               | ●         | ●         | ●                   | ●                    | ●                  |
+| **JDBC**    | ●               | ●         | ●         | ○               | ●         | ●         | ●                   | ●                    | ●                  |
+| **Python**  | ●               | ●         | ●         | ○               | ●         | ●         | ●                   | --                   | ●                  |
+| **Go**      | ●               | ●         | ●         | ○               | ●         | ●         | ○                   | --                   | --                 |
+| **NodeJs**  | ●               | ●         | ○         | ○               | ●         | ●         | ○                   | --                   | --                 |
+| **C#**      | ○               | ●         | ●         | ○               | ○         | ○         | ○                   | --                   | --                 |
+| **RESTful** | ●               | ●         | ●         | ●               | ●         | ●         | ●                   | ●                    | ●                  |
+注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
+请跳转到 [连接器 ](https://www.taosdata.com/cn/documentation/connector)查看更详细的信息。
--- a/documentation20/webdocs/markdowndocs/Model-ch.md
+++ b/documentation20/webdocs/markdowndocs/Model-ch.md
@@ -6,16 +6,16 @@ TDengine采用关系型数据模型，需要建库、建表。因此对于一个
 ## 创建库
-不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小等等。为让各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
+不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为让各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
-```cmd
+```mysql
-CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 4;
+CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 4 UPDATE 1;
 ```
-上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，内存块数为4。详细的语法及参数请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL</a>  
+上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，内存块数为4，允许更新数据。详细的语法及参数请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL</a>  
 创建库之后，需要使用SQL命令USE将当前库切换过来，例如：
-```cmd
+```mysql
 USE power;	
 ```
@@ -28,7 +28,7 @@ USE power;
 ## 创建超级表
 一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用TDengine, 需要对每个类型的数据采集点创建一超级表。以表一中的智能电表为例，可以使用如下的SQL命令创建超级表：
-```cmd
+```mysql
 CREATE TABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);
 ```
 与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义。第一列必须为时间戳（示例中为ts)，其他列为采集的物理量（示例中为current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 <a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>一节。

--- a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
+++ b/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
@@ -2,7 +2,7 @@
 本文档说明TAOS SQL支持的语法规则、主要查询功能、支持的SQL查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的SQL语言的基础。
-TAOS SQL是用户对TDengine进行数据写入和查询的主要工具。TAOS SQL为了便于用户快速上手，在一定程度上提供类似于标准SQL类似的风格和模式。严格意义上，TAOS SQL并不是也不试图提供SQL标准的语法。此外，由于TDengine针对的时序性结构化数据不提供修改和更新功能，因此在TAO SQL中不提供数据更新和数据删除的相关功能。
+TAOS SQL是用户对TDengine进行数据写入和查询的主要工具。TAOS SQL为了便于用户快速上手，在一定程度上提供类似于标准SQL类似的风格和模式。严格意义上，TAOS SQL并不是也不试图提供SQL标准的语法。此外，由于TDengine针对的时序性结构化数据不提供删除功能，因此在TAO SQL中不提供数据删除的相关功能。
 本章节SQL语法遵循如下约定：
@@ -57,18 +57,29 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 ## 数据库管理
 - **创建数据库**  
-    ```mysql
-    CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep];
+  ```mysql
-    ```
+  CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [UPDATE 1];
-    说明：
+  ```
+  说明：
-    1) `KEEP`是该数据库的数据保留多长天数，缺省是3650天(10年)，数据库会自动删除超过时限的数据；
-    2) 数据库名最大长度为33；
+  1) KEEP是该数据库的数据保留多长天数，缺省是3650天(10年)，数据库会自动删除超过时限的数据；
-    3) 一条SQL 语句的最大长度为65480个字符；
-    4) 数据库还有更多与存储相关的配置参数，请参见[系统管理](../administrator/#服务端配置)。
+  2) UPDATE 标志数据库支持更新相同时间戳数据；
+  3) 数据库名最大长度为33；
+  4) 一条SQL 语句的最大长度为65480个字符；
+  5) 数据库还有更多与存储相关的配置参数，请参见系统管理。
+- **显示系统当前参数**
+  ```mysql
+  SHOW VARIABLES;
+  ```
 - **使用数据库**
    ```mysql
    USE db_name;
    ```
@@ -143,6 +154,12 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    显示当前数据库下的所有数据表信息。说明：可在like中使用通配符进行名称的匹配。 通配符匹配：1）’%’ (百分号)匹配0到任意个字符；2）’_’下划线匹配一个字符。
+- **在线修改显示字符宽度**
+    ```mysql
+    SET MAX_BINARY_DISPLAY_WIDTH <nn>;
+    ```
 - **获取表的结构信息**
    ```mysql
@@ -1022,3 +1039,21 @@ SELECT AVG(current),MAX(current),LEASTSQUARES(current, start_val, step_val), PER
 - 标签最多允许128个，可以0个，标签总长度不超过16k个字符
 - SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
+##  TAOS SQL其他约定
+**group by的限制**
+TAOS  SQL支持对标签、tbname进行group by操作，也支持普通列进行group by，前提是：仅限一列且该列的唯一值小于10万个。
+**join操作的限制**
+TAOS SQL支持表之间按主键时间戳来join两张表的列，暂不支持两个表之间聚合后的四则运算。
+**is not null与不为空的表达式适用范围**
+is not null支持所有类型的列。不为空的表达式为 <>""，仅对非数值类型的列适用。
--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/webdocs/markdowndocs/administrator-ch.md
@@ -80,6 +80,12 @@ TDengine集群的节点数必须大于等于副本数，否则创建表时将报
 TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修改配置参数，以满足不同场景的需求。配置文件的缺省位置在/etc/taos目录，可以通过taosd命令行执行参数-c指定配置文件目录。比如taosd -c /home/user来指定配置文件位于/home/user这个目录。
+另外可以使用 “-C” 显示当前服务器配置参数：
+```
+taosd -C
+```
 下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节，而且这些参数的缺省配置都是工作的，一般无需设置。**注意：配置修改后，需要重启*taosd*服务才能生效。**
 - firstEp: taosd启动时，主动连接的集群中首个dnode的end point, 默认值为localhost:6030。
@@ -96,6 +102,8 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 - maxSQLLength：单条SQL语句允许最长限制。默认值：65380字节。
 - telemetryReporting: 是否允许 TDengine 采集和上报基本使用信息，0表示不允许，1表示允许。 默认值：1。
 - stream: 是否启用连续查询（流计算功能），0表示不允许，1表示允许。 默认值：1。
+- queryBufferSize: 为所有并发查询占用保留的内存大小。计算规则可以根据实际应用可能的最大并发数和表的数字相乘，再乘 170 。单位为字节。
+- ratioOfQueryCores: 设置查询线程的最大数量。最小值0 表示只有1个查询线程；最大值2表示最大建立2倍CPU核数的查询线程。默认为1，表示最大和CPU核数相等的查询线程。该值可以为小数，即0.5表示最大建立CPU核数一半的查询线程。
 **注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030都6042共13个端口，而且必须TCP和UDP都打开。
@@ -151,11 +159,20 @@ ALTER DNODE <dnode_id> <config>
 ## 客户端配置 
-TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。本节主要说明 taos 客户端应用在配置文件 taos.cfg 文件中使用到的参数。
+TDengine系统的前台交互客户端应用程序为taos，以及应用驱动，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。更多taos的使用方法请见[Shell命令行程序](https://www.taosdata.com/cn/documentation/administrator/#_TDengine_Shell命令行程序)。本节主要说明 taos 客户端应用在配置文件 taos.cfg 文件中使用到的参数。
+**2.0.10.0 之后版本支持命令行以下参数显示当前客户端参数的配置**
+```bash
+taos -C  或  taos --dump-config
+```
 客户端配置参数
 - firstEp: taos启动时，主动连接的集群中第一个taosd实例的end point, 缺省值为 localhost:6030。
+- secondEp: taos 启动时，如果 firstEp 连不上，将尝试连接 secondEp。
 - locale
    默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
@@ -211,15 +228,15 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
    均是合法的设置东八区时区的格式。
    时区的设置对于查询和写入SQL语句中非Unix时间戳的内容（时间戳字符串、关键词now的解析）产生影响。例如：
-    ```
+    ```sql
    SELECT count(*) FROM table_name WHERE TS<'2019-04-11 12:01:08';
    ```
    在东八区，SQL语句等效于
-    ```
+    ```sql
    SELECT count(*) FROM table_name WHERE TS<1554955268000;
    ```
    在UTC时区，SQL语句等效于
-    ```
+    ```sql
    SELECT count(*) FROM table_name WHERE TS<1554984068000;
    ```
    为了避免使用字符串时间格式带来的不确定性，也可以直接使用Unix时间戳。此外，还可以在SQL语句中使用带有时区的时间戳字符串，例如：RFC3339格式的时间戳字符串，2013-04-12T15:52:01.123+08:00或者ISO-8601格式时间戳字符串2013-04-12T15:52:01.123+0800。上述两个字符串转化为Unix时间戳不受系统所在时区的影响。
@@ -229,42 +246,42 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
 - maxBinaryDisplayWidth
    Shell中binary 和 nchar字段的显示宽度上限，超过此限制的部分将被隐藏。默认值：30。可在 shell 中通过命令 set max_binary_display_width nn 动态修改此选项。
 ## 用户管理
 系统管理员可以在CLI界面里添加、删除用户，也可以修改密码。CLI里SQL语法如下：
-```
+```sql
 CREATE USER <user_name> PASS <'password'>;
 ```
 创建用户，并指定用户名和密码，密码需要用单引号引起来,单引号为英文半角
-```
+```sql
 DROP USER <user_name>;
 ```
 删除用户，限root用户使用
-```
+```sql
 ALTER USER <user_name> PASS <'password'>;
 ```
 修改用户密码, 为避免被转换为小写，密码需要用单引号引用,单引号为英文半角
-```
+```sql
 ALTER USER <user_name> PRIVILEGE <super|write|read>;
 ```
 修改用户权限为：super/write/read，不需要添加单引号
-```
+```mysql
 SHOW USERS;
 ```
 显示所有用户  
 **注意：**SQL 语法中，< >表示需要用户输入的部分，但请不要输入< >本身
 ## 数据导入
@@ -312,12 +329,11 @@ taos> DESCRIBE d1001
 ```
 那么可以用如下命令导入数据
-```
+```mysql
 taos> insert into d1001 file '~/data.csv';
 Query OK, 9 row(s) affected (0.004763s)
 ```
 **taosdump工具导入**
 TDengine提供了方便的数据库导入导出工具taosdump。用户可以将taosdump从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见博客：<a href='https://www.taosdata.com/blog/2020/03/09/1334.html'>TDengine DUMP工具使用指南</a>
@@ -330,7 +346,7 @@ TDengine提供了方便的数据库导入导出工具taosdump。用户可以将t
 如果用户需要导出一个表或一个STable中的数据，可在shell中运行
-```
+```mysql
 select * from <tb_name> >> data.csv;
 ```
@@ -344,37 +360,37 @@ TDengine提供了方便的数据库导出工具taosdump。用户可以根据需
 系统管理员可以从CLI查询系统的连接、正在进行的查询、流式计算，并且可以关闭连接、停止正在进行的查询和流式计算。CLI里SQL语法如下：
-```
+```mysql
 SHOW CONNECTIONS;
 ```
 显示数据库的连接，其中一列显示ip:port, 为连接的IP地址和端口号。
-```
+```mysql
 KILL CONNECTION <connection-id>;
 ```
 强制关闭数据库连接，其中的connection-id是SHOW CONNECTIONS中显示的第一列的数字。
-```
+```mysql
 SHOW QUERIES;
 ```
 显示数据查询，其中第一列显示的以冒号隔开的两个数字为query-id，为发起该query应用连接的connection-id和查询次数。
-```
+```mysql
 KILL QUERY <query-id>;
 ```
 强制关闭数据查询，其中query-id是SHOW QUERIES中显示的 connection-id:query-no字串，如“105:2”，拷贝粘贴即可。
-```
+```mysql
 SHOW STREAMS;
 ```
 显示流式计算，其中第一列显示的以冒号隔开的两个数字为stream-id, 为启动该stream应用连接的connection-id和发起stream的次数。
-```
+```mysql
 KILL STREAM <stream-id>;
 ```
@@ -413,3 +429,65 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录。
+## TDengine参数限制与保留关键字
+- 数据库名：不能包含“.”以及特殊字符，不能超过32个字符
+- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符
+- 表的列名：不能包含特殊字符，不能超过64个字符
+- 表的列数：不能超过1024列
+- 记录的最大长度：包括时间戳8 byte，不能超过16KB
+- 单条SQL语句默认最大字符串长度：65480 byte
+- 数据库副本数：不能超过3
+- 用户名：不能超过20个byte
+- 用户密码：不能超过15个byte
+- 标签(Tags)数量：不能超过128个
+- 标签的总长度：不能超过16Kbyte
+- 记录条数：仅受存储空间限制
+- 表的个数：仅受节点个数限制
+- 库的个数：仅受节点个数限制
+- 单个库上虚拟节点个数：不能超过64个
+目前TDengine有将近200个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable名、数据列名及标签列名等。这些关键字列表如下：
+| 关键字列表 |             |              |            |           |
+| ---------- | ----------- | ------------ | ---------- | --------- |
+| ABLOCKS    | CONNECTION  | GT           | MINUS      | SHOW      |
+| ABORT      | CONNECTIONS | ID           | MNODES     | SLASH     |
+| ACCOUNT    | COPY        | IF           | MODULES    | SLIDING   |
+| ACCOUNTS   | COUNT       | IGNORE       | NCHAR      | SMALLINT  |
+| ADD        | CREATE      | IMMEDIATE    | NE         | SPREAD    |
+| AFTER      | CTIME       | IMPORT       | NONE       | STAR      |
+| ALL        | DATABASE    | IN           | NOT        | STATEMENT |
+| ALTER      | DATABASES   | INITIALLY    | NOTNULL    | STDDEV    |
+| AND        | DAYS        | INSERT       | NOW        | STREAM    |
+| AS         | DEFERRED    | INSTEAD      | OF         | STREAMS   |
+| ASC        | DELIMITERS  | INTEGER      | OFFSET     | STRING    |
+| ATTACH     | DESC        | INTERVAL     | OR         | SUM       |
+| AVG        | DESCRIBE    | INTO         | ORDER      | TABLE     |
+| BEFORE     | DETACH      | IP           | PASS       | TABLES    |
+| BEGIN      | DIFF        | IS           | PERCENTILE | TAG       |
+| BETWEEN    | DIVIDE      | ISNULL       | PLUS       | TAGS      |
+| BIGINT     | DNODE       | JOIN         | PRAGMA     | TBLOCKS   |
+| BINARY     | DNODES      | KEEP         | PREV       | TBNAME    |
+| BITAND     | DOT         | KEY          | PRIVILEGE  | TIMES     |
+| BITNOT     | DOUBLE      | KILL         | QUERIES    | TIMESTAMP |
+| BITOR      | DROP        | LAST         | QUERY      | TINYINT   |
+| BOOL       | EACH        | LE           | RAISE      | TOP       |
+| BOTTOM     | END         | LEASTSQUARES | REM        | TRIGGER   |
+| BY         | EQ          | LIKE         | REPLACE    | UMINUS    |
+| CACHE      | EXISTS      | LIMIT        | REPLICA    | UPLUS     |
+| CASCADE    | EXPLAIN     | LINEAR       | RESET      | USE       |
+| CHANGE     | FAIL        | LOCAL        | RESTRICT   | USER      |
+| CLOG       | FILL        | LP           | ROW        | USERS     |
+| CLUSTER    | FIRST       | LSHIFT       | ROWS       | USING     |
+| COLON      | FLOAT       | LT           | RP         | VALUES    |
+| COLUMN     | FOR         | MATCH        | RSHIFT     | VARIABLE  |
+| COMMA      | FROM        | MAX          | SCORES     | VGROUPS   |
+| COMP       | GE          | METRIC       | SELECT     | VIEW      |
+| CONCAT     | GLOB        | METRICS      | SEMI       | WAVG      |
+| CONFIGS    | GRANTS      | MIN          | SET        | WHERE     |
+| CONFLICT   | GROUP       |              |            |           |
--- a/documentation20/webdocs/markdowndocs/advanced features-ch.md
+++ b/documentation20/webdocs/markdowndocs/advanced features-ch.md
@@ -60,7 +60,7 @@ create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s
 会自动创建一个名为 `avg_vol` 的新表，然后每隔30秒，TDengine会增量执行 `as` 后面的 SQL 语句，
 并将查询结果写入这个表中，用户程序后续只要从 `avg_vol` 中查询数据即可。 例如：
-```shell
+```mysql
 taos> select * from avg_vol;
            ts           |        avg_voltage_    |
 ===================================================
@@ -72,14 +72,13 @@ taos> select * from avg_vol;
 需要注意，查询时间窗口的最小值是10毫秒，没有时间窗口范围的上限。
 此外，TDengine还支持用户指定连续查询的起止时间。
 如果不输入开始时间，连续查询将从第一条原始数据所在的时间窗口开始；
 如果没有输入结束时间，连续查询将永久运行；
 如果用户指定了结束时间，连续查询在系统时间达到指定的时间以后停止运行。
 比如使用下面的SQL创建的连续查询将运行一小时，之后会自动停止。
-```sql
+```mysql
 create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
 ```

--- a/documentation20/webdocs/markdowndocs/cluster-ch.md
+++ b/documentation20/webdocs/markdowndocs/cluster-ch.md
@@ -137,6 +137,16 @@ DROP DNODE "fqdn:port";
 其中fqdn是被删除的节点的FQDN，port是其对外服务器的端口号
+<font color=green>**【注意】**</font>
+  - 一个数据节点一旦被drop之后，不能重新加入集群。需要将此节点重新部署（清空数据文件夹）。集群在完成drop dnode操作之前，会将该dnode的数据迁移走。
+  - 请注意 drop dnode 和 停止taosd进程是两个不同的概念，不要混淆：因为删除dnode之前要执行迁移数据的操作，因此被删除的dnode必须保持在线状态。待删除操作结束之后，才能停止taosd进程。
+  - 一个数据节点被drop之后，其他节点都会感知到这个dnodeID的删除操作，任何集群中的节点都不会再接收此dnodeID的请求。
+  - dnodeID的是集群自动分配的，不得人工指定。它在生成时递增的，不会重复。
 ### 查看数据节点
 执行CLI程序taos,使用root账号登录进TDengine系统，执行：

--- a/documentation20/webdocs/markdowndocs/connector-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-ch.md
 # 连接器
-TDengine提供了丰富的应用程序开发接口，其中包括C/C++、JAVA、Python、RESTful、Go等，便于用户快速开发应用。
+TDengine提供了丰富的应用程序开发接口，其中包括C/C++、C# 、Java、Python、Go、Node.js、RESTful 等，便于用户快速开发应用。
-注意：所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+![image-connecotr](../assets/connector.png)
+目前TDengine的连接器可支持的平台广泛，目前包括：X64/X86/ARM64/ARM32/MIPS/Alpha等硬件平台，以及Linux/Win64/Win32等开发环境。对照矩阵如下：
+| **CPU**     | **X64   64bit** | **X64   64bit** | **X64   64bit** | **X86   32bit** | **ARM64** | **ARM32** | **MIPS   龙芯** | **Alpha   申威** | **X64   海光** |
+| ----------- | --------------- | --------------- | --------------- | --------------- | --------- | --------- | --------------- | ---------------- | -------------- |
+| **OS**      | **Linux**       | **Win64**       | **Win32**       | **Win32**       | **Linux** | **Linux** | **Linux**       | **Linux**        | **Linux**      |
+| **C/C++**   | ●               | ●               | ●               | ○               | ●         | ●         | ●               | ●                | ●              |
+| **JDBC**    | ●               | ●               | ●               | ○               | ●         | ●         | ●               | ●                | ●              |
+| **Python**  | ●               | ●               | ●               | ○               | ●         | ●         | ●               | --               | ●              |
+| **Go**      | ●               | ●               | ●               | ○               | ●         | ●         | ○               | --               | --             |
+| **NodeJs**  | ●               | ●               | ○               | ○               | ●         | ●         | ○               | --               | --             |
+| **C#**      | ○               | ●               | ●               | ○               | ○         | ○         | ○               | --               | --             |
+| **RESTful** | ●               | ●               | ●               | ●               | ●         | ●         | ●               | ●                | ●              |
+其中 ● 表示经过官方测试验证， ○ 表示非官方测试验证。
+注意：
+* 所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+* 升级到TDengine到2.0.8.0版本的用户，必须更新JDBC连接TDengine必须升级taos-jdbcdriver到2.0.12及以上。
 ## C/C++ Connector
@@ -285,7 +305,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
 ### 安装准备
 * 已安装TDengine, 如果客户端在Windows上，需要安装Windows 版本的TDengine客户端 [（Windows TDengine 客户端安装）][4]
 * 已安装python 2.7 or >= 3.4
-* 已安装pip
+* 已安装pip 或 pip3
 ### Python客户端安装
@@ -297,7 +317,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
 或
-		`pip install src/connector/python/linux/python3/`
+		`pip3 install src/connector/python/linux/python3/`
 #### Windows
 在已安装Windows TDengine 客户端的情况下， 将文件"C:\TDengine\driver\taos.dll" 拷贝到 "C:\windows\system32" 目录下, 然后进入Windwos <em>cmd</em> 命令行界面
@@ -457,13 +477,13 @@ HTTP请求的BODY里就是一个完整的SQL语句，SQL语句中的数据表应
 使用curl通过自定义身份认证方式来发起一个HTTP Request，语法如下：
-```
+```bash
 curl -H 'Authorization: Basic <TOKEN>' -d '<SQL>' <ip>:<PORT>/rest/sql
 ```
 或者
-```
+```bash
 curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 ```
@@ -473,7 +493,7 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 返回值为JSON格式，如下:
-```
+```json
 {
    "status": "succ",
    "head": ["Time Stamp","current", …],
@@ -496,7 +516,7 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 HTTP请求中需要带有授权码`<TOKEN>`，用于身份识别。授权码通常由管理员提供，可简单的通过发送`HTTP GET`请求来获取授权码，操作如下：
-```
+```bash
 curl http://<ip>:6041/rest/login/<username>/<password>
 ```
@@ -510,13 +530,13 @@ curl http://<ip>:6041/rest/login/<username>/<password>
 获取授权码示例：
-```
+```bash
 curl http://192.168.0.1:6041/rest/login/root/taosdata
 ```
 返回值：
-```
+```json
 {
  "status": "succ",
  "code": 0,
@@ -528,12 +548,12 @@ curl http://192.168.0.1:6041/rest/login/root/taosdata
 - 在demo库里查询表d1001的所有记录： 
-```
+```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sql
 ```
 返回值：
-```
+```json
 {
    "status": "succ",
    "head": ["Time Stamp","current","voltage","phase"],
@@ -547,12 +567,12 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 - 创建库demo：
-```
+```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 192.168.0.1:6041/rest/sql
 ```
 返回值：
-```
+```json
 {
    "status": "succ",
    "head": ["affected_rows"],
@@ -567,13 +587,13 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 19
 HTTP请求URL采用`sqlt`时，返回结果集的时间戳将采用Unix时间戳格式表示，例如
-```
+```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sqlt
 ```
 返回值：
-```
+```json
 {
    "status": "succ",
    "head": ["column1","column2","column3"],
@@ -588,13 +608,13 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 #### 结果集采用UTC时间字符串
 HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间字符串表示，例如
-```
+```bash
  curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.t1' 192.168.0.1:6041/rest/sqlutc
 ```
 返回值：
-```
+```json
 {
    "status": "succ",
    "head": ["column1","column2","column3"],
@@ -664,30 +684,52 @@ import (
    _ "github.com/taosdata/driver-go/taosSql"
 )
 ```
+**建议Go版本是1.13或以上，并开启模块支持：**
+```
+go env -w GO111MODULE=on  
+go env -w GOPROXY=https://goproxy.io,direct  
+```
 ### 常用API
-* `sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 
+- sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 
-	该API用来打开DB，返回一个类型为*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
+  该API用来打开DB，返回一个类型为*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
-   **注意**： 该API成功创建的时候，并没有做权限等检查，只有在真正执行Query或者Exec的时候才能真正的去创建连接，并同时检查user/password/host/port是不是合法。 另外，由于整个驱动程序大部分实现都下沉到taosSql所依赖的libtaos中。所以，sql.Open本身特别轻量。 
+  **注意**： 该API成功创建的时候，并没有做权限等检查，只有在真正执行Query或者Exec的时候才能真正的去创建连接，并同时检查user/password/host/port是不是合法。 另外，由于整个驱动程序大部分实现都下沉到taosSql所依赖的libtaos中。所以，sql.Open本身特别轻量。 
-*  `func (db *DB) Exec(query string, args ...interface{}) (Result, error)`
+-  `func (db *DB) Exec(query string, args ...interface{}) (Result, error)`
  sql.Open内置的方法，用来执行非查询相关SQL
+-  `func (db *DB) Query(query string, args ...interface{}) (*Rows, error)`
-*  `func (db *DB) Query(query string, args ...interface{}) (*Rows, error)`
  sql.Open内置的方法，用来执行查询语句
+- `func (db *DB) Prepare(query string) (*Stmt, error)`
+  sql.Open内置的方法，Prepare creates a prepared statement for later queries or executions.
+- `func (s *Stmt) Exec(args ...interface{}) (Result, error)`
+  sql.Open内置的方法，executes a prepared statement with the given arguments and returns a Result summarizing the effect of the statement.
+- `func (s *Stmt) Query(args ...interface{}) (*Rows, error)`
+  sql.Open内置的方法，Query executes a prepared query statement with the given arguments and returns the query results as a *Rows.
+- `func (s *Stmt) Close() error`
+  sql.Open内置的方法，Close closes the statement.	
 ## Node.js Connector
 TDengine 同时也提供了node.js 的连接器。用户可以通过[npm](https://www.npmjs.com/)来进行安装，也可以通过源代码*src/connector/nodejs/* 来进行安装。[具体安装步骤如下](https://github.com/taosdata/tdengine/tree/master/src/connector/nodejs)：
 首先，通过[npm](https://www.npmjs.com/)安装node.js 连接器.
-```cmd
+```bash
 npm install td2.0-connector
 ```
 我们建议用户使用npm 安装node.js连接器。如果您没有安装npm, 可以将*src/connector/nodejs/*拷贝到您的nodejs 项目目录下
@@ -701,32 +743,6 @@ npm install td2.0-connector
 - `make`
 - c语言编译器比如[GCC](https://gcc.gnu.org)
-### macOS
- `python` (建议`v2.7` , `v3.x.x` 目前还不支持)
- Xcode
-    - 然后通过Xcode安装
-    ```
-    Command Line Tools
-    ```
-    在
-    ```
-    Xcode -> Preferences -> Locations
-    ```
-    目录下可以找到这个工具。或者在终端里执行
-    ```
-    xcode-select --install
-    ```
-    - 该步执行后 `gcc` 和 `make`就被安装上了
 ### Windows
 #### 安装方法1

--- a/documentation20/webdocs/markdowndocs/connector-java-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-java-ch.md
 #  Java Connector
+Java连接器支持的系统有： Linux 64/Windows x64/Windows x86。
 TDengine 为了方便 Java 应用使用，提供了遵循 JDBC 标准(3.0)API 规范的 `taos-jdbcdriver` 实现。目前可以通过 [Sonatype Repository][1] 搜索并下载。
 由于 TDengine 是使用 c 语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
@@ -24,7 +26,8 @@ TDengine 的 JDBC 驱动实现尽可能的与关系型数据库驱动保持一
 | taos-jdbcdriver 版本 | TDengine 版本 | JDK 版本 |
 | --- | --- | --- |
-| 2.0.4 | 2.0.0.x 及以上 | 1.8.x |
+| 2.0.12 及以上 | 2.0.8.0 及以上 | 1.8.x |
+| 2.0.4 - 2.0.11 | 2.0.0.0 - 2.0.7.x | 1.8.x |
 | 1.0.3 | 1.6.1.x 及以上 | 1.8.x |
 | 1.0.2 | 1.6.1.x 及以上 | 1.8.x |
 | 1.0.1 | 1.6.1.x 及以上 | 1.8.x |

--- a/documentation20/webdocs/markdowndocs/faq-ch.md
+++ b/documentation20/webdocs/markdowndocs/faq-ch.md
@@ -117,7 +117,17 @@ Connection = DriverManager.getConnection(url, properties);
-## 16. 怎么报告问题？
+## 16. 如何进行数据迁移？
+TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A移动机器B时，注意如下两件事：
+- 2.0.0.0 至 2.0.6.x 的版本，重新配置机器B的hostname为机器A的hostname
+- 2.0.7.0 及以后的版本，到/var/lib/taos/dnode下，修复dnodeEps.json的dnodeId对应的FQDN，重启。确保机器内所有机器的此文件是完全相同的。
+- 1.x 和 2.x 版本的存储结构不兼容，需要使用迁移工具或者自己开发应用导出导入数据。
+## 17. 怎么报告问题？
 如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包:
 1. /var/log/taos

--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/webdocs/markdowndocs/insert-ch.md
@@ -24,7 +24,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 - 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置，最大可配置为1M）。
 - TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程切频繁切换，带来额外开销。
- 对同一张表，如果新插入记录的时间戳已经存在，新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。
+- 对同一张表，如果新插入记录的时间戳已经存在，默认（没有使用 UPDATE 1 创建数据库）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
 - 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还老的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days配置为2，那么无法写入比当前时间还晚2天的数据。
 ## Prometheus直接写入
@@ -37,7 +37,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 - 对应的TDengine版本。因为用到了TDengine的客户端动态链接库，因此需要安装好和服务端相同版本的TDengine程序；比如服务端版本是TDengine 2.0.0, 则在bailongma所在的linux服务器（可以与TDengine在同一台服务器，或者不同服务器）
 Bailongma项目中有一个文件夹blm_prometheus，存放了prometheus的写入API程序。编译过程如下：
-```
+```bash
 cd blm_prometheus
 go build
 ```
@@ -79,7 +79,7 @@ blm_prometheus对prometheus提供服务的端口号。
 ### 启动示例
 通过以下命令启动一个blm_prometheus的API服务
-```
+```bash
 ./blm_prometheus -port 8088
 ```
 假设blm_prometheus所在服务器的IP地址为"10.1.2.3"，则在prometheus的配置文件中<remote_write>部分增加url为
@@ -107,7 +107,7 @@ prometheus产生的数据格式如下：
 }
 ```
 其中，apiserver_request_latencies_bucket为prometheus采集的时序数据的名称，后面{}中的为该时序数据的标签。blm_prometheus会以时序数据的名称在TDengine中自动创建一个超级表，并将{}中的标签转换成TDengine的tag值，Timestamp作为时间戳，value作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。
-```
+```mysql
 use prometheus;
 select * from apiserver_request_latencies_bucket;
 ```
@@ -124,7 +124,7 @@ select * from apiserver_request_latencies_bucket;
 Bailongma项目中有一个文件夹blm_telegraf，存放了Telegraf的写入API程序。编译过程如下：
-```
+```bash
 cd blm_telegraf
 go build
 ```
@@ -175,7 +175,7 @@ blm_telegraf对telegraf提供服务的端口号。
 ### 启动示例
 通过以下命令启动一个blm_telegraf的API服务
-```
+```bash
 ./blm_telegraf -host 127.0.0.1 -port 8089
 ```
@@ -213,7 +213,7 @@ telegraf产生的数据格式如下：
 其中，name字段为telegraf采集的时序数据的名称，tags字段为该时序数据的标签。blm_telegraf会以时序数据的名称在TDengine中自动创建一个超级表，并将tags字段中的标签转换成TDengine的tag值，Timestamp作为时间戳，fields字段中的值作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。
-```
+```mysql
 use telegraf;
 select * from cpu;
 ```

--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -29,8 +29,12 @@
 # number of threads per CPU core
 # numOfThreadsPerCore       1.0
-# the proportion of total threads responsible for query
+# the proportion of total CPU cores available for query processing
-# ratioOfQueryThreads       0.5
+# 2.0: the query threads will be set to double of the CPU cores.
+# 1.0: all CPU cores are available for query processing [default].
+# 0.5: only half of the CPU cores are available for query.
+# 0.0: only one core available.
+# tsRatioOfQueryCores       1.0
 # number of management nodes in the system
 # numOfMnodes               3
@@ -265,5 +269,5 @@
 # enable/disable stream (continuous query)
 # stream                1
-# only 50% CPU resources will be used in query processing
+# in retrieve blocking model, only in 50% query threads will be used in query processing in dnode
-# halfCoresForQuery     0
+# retrieveBlockingModel    0
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -9,6 +9,9 @@ set -e
 verMode=edge
 pagMode=full
+iplist=""
+serverFqdn=""
 # -----------------------Variables definition---------------------
 script_dir=$(dirname $(readlink -f "$0"))
 # Dynamic directory
@@ -227,6 +230,157 @@ function install_header() {
    ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
 }
+function add_newHostname_to_hosts() {
+  localIp="127.0.0.1"
+  OLD_IFS="$IFS"
+  IFS=" "
+  iphost=$(cat /etc/hosts | grep $1 | awk '{print $1}')
+  arr=($iphost)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+    if [[ "$s" == "$localIp" ]]; then
+      return
+    fi
+  done 
+  ${csudo} echo "127.0.0.1  $1" >> /etc/hosts   ||:
+}
+function set_hostname() {
+  echo -e -n "${GREEN}Please enter one hostname(must not be 'localhost')${NC}:"
+	read newHostname
+  while true; do
+    if [[ ! -z "$newHostname" && "$newHostname" != "localhost" ]]; then
+      break
+    else
+      read -p "Please enter one hostname(must not be 'localhost'):" newHostname
+    fi
+  done
+  ${csudo} hostname $newHostname ||:
+  retval=`echo $?`
+  if [[ $retval != 0 ]]; then
+   echo
+   echo "set hostname fail!"
+   return 
+  fi
+  #echo -e -n "$(hostnamectl status --static)"
+  #echo -e -n "$(hostnamectl status --transient)"
+  #echo -e -n "$(hostnamectl status --pretty)"
+  #ubuntu/centos /etc/hostname
+  if [[ -e /etc/hostname ]]; then
+    ${csudo} echo $newHostname > /etc/hostname   ||:
+  fi
+  #debian: #HOSTNAME=yourname
+  if [[ -e /etc/sysconfig/network ]]; then
+    ${csudo} sed -i -r "s/#*\s*(HOSTNAME=\s*).*/\1$newHostname/" /etc/sysconfig/network   ||:
+  fi
+  ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$newHostname/" ${cfg_install_dir}/taos.cfg
+  serverFqdn=$newHostname  
+  if [[ -e /etc/hosts ]]; then
+    add_newHostname_to_hosts $newHostname
+  fi
+}
+function is_correct_ipaddr() {
+  newIp=$1
+  OLD_IFS="$IFS"
+  IFS=" "
+  arr=($iplist)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+   if [[ "$s" == "$newIp" ]]; then
+     return 0
+   fi
+  done
+  return 1
+}
+function set_ipAsFqdn() {
+  iplist=$(ip address |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F "/" '{print $1}') ||:
+  if [ -z "$iplist" ]; then
+    iplist=$(ifconfig |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F ":" '{print $2}') ||:
+  fi
+  if [ -z "$iplist" ]; then
+    echo
+    echo -e -n "${GREEN}Unable to get local ip, use 127.0.0.1${NC}"
+    localFqdn="127.0.0.1"
+    # Write the local FQDN to configuration file                    
+    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+    serverFqdn=$localFqdn
+    echo
+    return
+  fi  
+  echo -e -n "${GREEN}Please choose an IP from local IP list${NC}:"
+  echo
+  echo -e -n "${GREEN}$iplist${NC}"
+  echo
+  echo
+  echo -e -n "${GREEN}Notes: if IP is used as the node name, data can NOT be migrated to other machine directly${NC}:"
+  read localFqdn
+    while true; do
+      if [ ! -z "$localFqdn" ]; then            
+        # Check if correct ip address
+        is_correct_ipaddr $localFqdn
+        retval=`echo $?`
+        if [[ $retval != 0 ]]; then
+          read -p "Please choose an IP from local IP list:" localFqdn
+        else
+          # Write the local FQDN to configuration file                    
+          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+          serverFqdn=$localFqdn
+          break
+        fi
+      else
+        read -p "Please choose an IP from local IP list:" localFqdn
+      fi
+    done
+}
+function local_fqdn_check() {
+  #serverFqdn=$(hostname -f)
+  echo
+  echo -e -n "System hostname is: ${GREEN}$serverFqdn${NC}"
+  echo
+  if [[ "$serverFqdn" == "" ]] || [[ "$serverFqdn" == "localhost"  ]]; then    
+    echo -e -n "${GREEN}It is strongly recommended to configure a hostname for this machine ${NC}"
+    echo
+    while true
+    do
+	    read -r -p "Set hostname now? [Y/n] " input
+	    if [ ! -n "$input" ]; then
+       set_hostname
+       break
+      else
+	      case $input in
+	        [yY][eE][sS]|[yY])
+          set_hostname
+          break
+			    ;;
+	        [nN][oO]|[nN])
+			    set_ipAsFqdn
+			    break   	
+			    ;;
+	        *)
+			    echo "Invalid input..."
+			    ;;
+	      esac
+	    fi
+    done
+  fi
+}
 function install_config() {
    #${csudo} rm -f ${install_main_dir}/cfg/taos.cfg     || :
@@ -247,7 +401,9 @@ function install_config() {
    if [ "$interactiveFqdn" == "no" ]; then
        return 0
-    fi
+    fi   	
+    local_fqdn_check
    #FQDN_FORMAT="(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
    #FQDN_FORMAT="(:[1-6][0-9][0-9][0-9][0-9]$)"
@@ -446,6 +602,9 @@ function install_service_on_systemd() {
    ${csudo} bash -c "echo '[Service]'                          >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'Type=simple'                        >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'ExecStart=/usr/bin/taosd'           >> ${taosd_service_config}"
+    #${csudo} bash -c "echo 'ExecStartPre=/usr/local/taos/bin/setDelay.sh'     >> ${taosd_service_config}"
+    #${csudo} bash -c "echo 'ExecStartPost=/usr/local/taos/bin/resetDelay.sh'  >> ${taosd_service_config}"
+    #${csudo} bash -c "echo 'ExecStopPost=/usr/local/taos/bin/resetDelay.sh'   >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'LimitNOFILE=infinity'               >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'LimitNPROC=infinity'                >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'LimitCORE=infinity'                 >> ${taosd_service_config}"
@@ -454,6 +613,7 @@ function install_service_on_systemd() {
    ${csudo} bash -c "echo 'Restart=always'                     >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'StartLimitBurst=3'                  >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'StartLimitInterval=60s'             >> ${taosd_service_config}"
+    #${csudo} bash -c "echo 'StartLimitIntervalSec=60s'          >> ${taosd_service_config}"
    ${csudo} bash -c "echo                                      >> ${taosd_service_config}"
    ${csudo} bash -c "echo '[Install]'                          >> ${taosd_service_config}"
    ${csudo} bash -c "echo 'WantedBy=multi-user.target'         >> ${taosd_service_config}"
@@ -634,9 +794,9 @@ function update_TDengine() {
        fi
        if [ ${openresty_work} = 'true' ]; then
-            echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+            echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos -h $serverFqdn${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
        else
-            echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+            echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos -h $serverFqdn${NC} in shell${NC}"
        fi
        echo
@@ -655,8 +815,8 @@ function update_TDengine() {
 function install_TDengine() {
    # Start to install
    if [ ! -e taos.tar.gz ]; then
-        echo "File taos.tar.gz does not exist"
+      echo "File taos.tar.gz does not exist"
-        exit 1
+      exit 1
    fi
    tar -zxf taos.tar.gz
@@ -702,41 +862,54 @@ function install_TDengine() {
        echo
        echo -e "${GREEN_DARK}To configure TDengine ${NC}: edit /etc/taos/taos.cfg"
        if ((${service_mod}==0)); then
-            echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} systemctl start taosd${NC}"
+          echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} systemctl start taosd${NC}"
        elif ((${service_mod}==1)); then
-            echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} service taosd start${NC}"
+          echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} service taosd start${NC}"
        else
-            echo -e "${GREEN_DARK}To start TDengine     ${NC}: taosd${NC}"
+          echo -e "${GREEN_DARK}To start TDengine     ${NC}: taosd${NC}"
        fi		
-        if [ ${openresty_work} = 'true' ]; then
+        #if [ ${openresty_work} = 'true' ]; then
-             echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+        #     echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
-        else
+        #else
-             echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+        #     echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
-        fi
+        #fi
        if [ ! -z "$firstEp" ]; then
-	    echo		    
+          tmpFqdn=${firstEp%%:*}
-	    echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp${GREEN_DARK} to login into cluster, then${NC}"
+          substr=":"
-	    echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+          if [[ $firstEp =~ $substr ]];then
-            echo
+            tmpPort=${firstEp#*:}
+          else
+            tmpPort=""
+          fi
+          if [[ "$tmpPort" != "" ]];then
+	          echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+	        else
+	          echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+	        fi
+	        echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+          echo
+        elif [ ! -z "$serverFqdn" ]; then
+	        echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $serverFqdn${GREEN_DARK} to login into TDengine server${NC}"
+          echo
        fi
        echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
        echo       
    else # Only install client
        install_bin
        install_config
        echo
        echo -e "\033[44;32;1mTDengine client is installed successfully!${NC}"
    fi
    touch ~/.taos_history
    rm -rf $(tar -tf taos.tar.gz)
 }
 ## ==============================Main program starts from here============================
+serverFqdn=$(hostname -f)
 if [ "$verType" == "server" ]; then
    # Install server and client
    if [ -x ${bin_dir}/taosd ]; then

--- a/packaging/tools/install_power.sh
+++ b/packaging/tools/install_power.sh
@@ -9,6 +9,8 @@ set -e
 verMode=edge
 pagMode=full
+iplist=""
+serverFqdn=""
 # -----------------------Variables definition---------------------
 script_dir=$(dirname $(readlink -f "$0"))
 # Dynamic directory
@@ -172,7 +174,6 @@ function install_bin() {
    ${csudo} rm -f ${bin_link_dir}/power     || :
    ${csudo} rm -f ${bin_link_dir}/powerd    || :
    ${csudo} rm -f ${bin_link_dir}/powerdemo || :
-    ${csudo} rm -f ${bin_link_dir}/powerdump || :
    ${csudo} rm -f ${bin_link_dir}/rmpower   || :
    ${csudo} rm -f ${bin_link_dir}/tarbitrator   || :
    ${csudo} rm -f ${bin_link_dir}/set_core   || :
@@ -183,7 +184,6 @@ function install_bin() {
    [ -x ${install_main_dir}/bin/power ] && ${csudo} ln -s ${install_main_dir}/bin/power ${bin_link_dir}/power                        || :
    [ -x ${install_main_dir}/bin/powerd ] && ${csudo} ln -s ${install_main_dir}/bin/powerd ${bin_link_dir}/powerd                     || :
    [ -x ${install_main_dir}/bin/powerdemo ] && ${csudo} ln -s ${install_main_dir}/bin/powerdemo ${bin_link_dir}/powerdemo            || :
-    [ -x ${install_main_dir}/bin/powerdump ] && ${csudo} ln -s ${install_main_dir}/bin/powerdump ${bin_link_dir}/powerdump            || :
    [ -x ${install_main_dir}/bin/remove_power.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_power.sh ${bin_link_dir}/rmpower  || :
    [ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core         || :
    [ -x ${install_main_dir}/bin/tarbitrator ] && ${csudo} ln -s ${install_main_dir}/bin/tarbitrator ${bin_link_dir}/tarbitrator      || :
@@ -227,6 +227,157 @@ function install_header() {
    ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
 }
+function add_newHostname_to_hosts() {
+  localIp="127.0.0.1"
+  OLD_IFS="$IFS"
+  IFS=" "
+  iphost=$(cat /etc/hosts | grep $1 | awk '{print $1}')
+  arr=($iphost)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+    if [[ "$s" == "$localIp" ]]; then
+      return
+    fi
+  done 
+  ${csudo} echo "127.0.0.1  $1" >> /etc/hosts   ||:
+}
+function set_hostname() {
+  echo -e -n "${GREEN}Please enter one hostname(must not be 'localhost')${NC}:"
+	read newHostname
+  while true; do
+    if [[ ! -z "$newHostname" && "$newHostname" != "localhost" ]]; then
+      break
+    else
+      read -p "Please enter one hostname(must not be 'localhost'):" newHostname
+    fi
+  done
+  ${csudo} hostname $newHostname ||:
+  retval=`echo $?`
+  if [[ $retval != 0 ]]; then
+   echo
+   echo "set hostname fail!"
+   return 
+  fi
+  #echo -e -n "$(hostnamectl status --static)"
+  #echo -e -n "$(hostnamectl status --transient)"
+  #echo -e -n "$(hostnamectl status --pretty)"
+  #ubuntu/centos /etc/hostname
+  if [[ -e /etc/hostname ]]; then
+    ${csudo} echo $newHostname > /etc/hostname   ||:
+  fi
+  #debian: #HOSTNAME=yourname
+  if [[ -e /etc/sysconfig/network ]]; then
+    ${csudo} sed -i -r "s/#*\s*(HOSTNAME=\s*).*/\1$newHostname/" /etc/sysconfig/network   ||:
+  fi
+  ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$newHostname/" ${cfg_install_dir}/taos.cfg
+  serverFqdn=$newHostname  
+  if [[ -e /etc/hosts ]]; then
+    add_newHostname_to_hosts $newHostname
+  fi
+}
+function is_correct_ipaddr() {
+  newIp=$1
+  OLD_IFS="$IFS"
+  IFS=" "
+  arr=($iplist)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+   if [[ "$s" == "$newIp" ]]; then
+     return 0
+   fi
+  done
+  return 1
+}
+function set_ipAsFqdn() {
+  iplist=$(ip address |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F "/" '{print $1}') ||:
+  if [ -z "$iplist" ]; then
+    iplist=$(ifconfig |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F ":" '{print $2}') ||:
+  fi
+  if [ -z "$iplist" ]; then
+    echo
+    echo -e -n "${GREEN}Unable to get local ip, use 127.0.0.1${NC}"
+    localFqdn="127.0.0.1"
+    # Write the local FQDN to configuration file                    
+    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+    serverFqdn=$localFqdn
+    echo
+    return
+  fi  
+  echo -e -n "${GREEN}Please choose an IP from local IP list${NC}:"
+  echo
+  echo -e -n "${GREEN}$iplist${NC}"
+  echo
+  echo
+  echo -e -n "${GREEN}Notes: if IP is used as the node name, data can NOT be migrated to other machine directly${NC}:"
+  read localFqdn
+    while true; do
+      if [ ! -z "$localFqdn" ]; then            
+        # Check if correct ip address
+        is_correct_ipaddr $localFqdn
+        retval=`echo $?`
+        if [[ $retval != 0 ]]; then
+          read -p "Please choose an IP from local IP list:" localFqdn
+        else
+          # Write the local FQDN to configuration file                    
+          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+          serverFqdn=$localFqdn
+          break
+        fi
+      else
+        read -p "Please choose an IP from local IP list:" localFqdn
+      fi
+    done
+}
+function local_fqdn_check() {
+  #serverFqdn=$(hostname -f)
+  echo
+  echo -e -n "System hostname is: ${GREEN}$serverFqdn${NC}"
+  echo
+  if [[ "$serverFqdn" == "" ]] || [[ "$serverFqdn" == "localhost"  ]]; then    
+    echo -e -n "${GREEN}It is strongly recommended to configure a hostname for this machine ${NC}"
+    echo
+    while true
+    do
+	    read -r -p "Set hostname now? [Y/n] " input
+	    if [ ! -n "$input" ]; then
+       set_hostname
+       break
+      else
+	      case $input in
+	        [yY][eE][sS]|[yY])
+          set_hostname
+          break
+			    ;;
+	        [nN][oO]|[nN])
+			    set_ipAsFqdn
+			    break   	
+			    ;;
+	        *)
+			    echo "Invalid input..."
+			    ;;
+	      esac
+	    fi
+    done
+  fi
+}
 function install_config() {
    #${csudo} rm -f ${install_main_dir}/cfg/taos.cfg     || :
@@ -248,6 +399,8 @@ function install_config() {
    if [ "$interactiveFqdn" == "no" ]; then
        return 0
    fi
+    local_fqdn_check
    #FQDN_FORMAT="(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
    #FQDN_FORMAT="(:[1-6][0-9][0-9][0-9][0-9]$)"
@@ -611,9 +764,9 @@ function update_PowerDB() {
        fi
        if [ ${openresty_work} = 'true' ]; then
-            echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+            echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power -h $serverFqdn${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
        else
-            echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell${NC}"
+            echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power -h $serverFqdn${NC} in shell${NC}"
        fi
        echo
@@ -686,17 +839,30 @@ function install_PowerDB() {
            echo -e "${GREEN_DARK}To start PowerDB     ${NC}: powerd${NC}"
        fi		
-        if [ ${openresty_work} = 'true' ]; then
+        #if [ ${openresty_work} = 'true' ]; then
-             echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+        #     echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
-        else
+        #else
-             echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell${NC}"
+        #     echo -e "${GREEN_DARK}To access PowerDB    ${NC}: use ${GREEN_UNDERLINE}power${NC} in shell${NC}"
-        fi
+        #fi
        if [ ! -z "$firstEp" ]; then
-	        echo		    
+          tmpFqdn=${firstEp%%:*}
-	        echo -e "${GREEN_DARK}Please run${NC}: power -h $firstEp${GREEN_DARK} to login into cluster, then${NC}"
+          substr=":"
+          if [[ $firstEp =~ $substr ]];then
+            tmpPort=${firstEp#*:}
+          else
+            tmpPort=""
+          fi
+          if [[ "$tmpPort" != "" ]];then
+	          echo -e "${GREEN_DARK}To access PowerDB    ${NC}: power -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+	        else
+	          echo -e "${GREEN_DARK}To access PowerDB    ${NC}: power -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+	        fi
 	        echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
          echo
+        elif [ ! -z "$serverFqdn" ]; then
+	        echo -e "${GREEN_DARK}To access PowerDB    ${NC}: power -h $serverFqdn${GREEN_DARK} to login into PowerDB server${NC}"
+          echo
        fi
        echo -e "\033[44;32;1mPowerDB is installed successfully!${NC}"
        echo       
@@ -713,6 +879,7 @@ function install_PowerDB() {
 ## ==============================Main program starts from here============================
+serverFqdn=$(hostname -f)
 if [ "$verType" == "server" ]; then
    # Install server and client
    if [ -x ${bin_dir}/powerd ]; then

--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@@ -3,6 +3,10 @@
 # This file is used to install tdengine rpm package on centos systems. The operating system 
 # is required to use systemd to manage services at boot
 #set -x
+iplist=""
+serverFqdn=""
 # -----------------------Variables definition---------------------
 script_dir=$(dirname $(readlink -f "$0"))
 # Dynamic directory
@@ -92,7 +96,6 @@ function install_bin() {
    ${csudo} rm -f ${bin_link_dir}/taos     || :
    ${csudo} rm -f ${bin_link_dir}/taosd    || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo || :
-    ${csudo} rm -f ${bin_link_dir}/taosdump || :
    ${csudo} rm -f ${bin_link_dir}/rmtaos   || :
    ${csudo} rm -f ${bin_link_dir}/set_core || :
@@ -102,10 +105,160 @@ function install_bin() {
    [ -x ${bin_dir}/taos ] && ${csudo} ln -s ${bin_dir}/taos ${bin_link_dir}/taos             || :
    [ -x ${bin_dir}/taosd ] && ${csudo} ln -s ${bin_dir}/taosd ${bin_link_dir}/taosd          || :
    [ -x ${bin_dir}/taosdemo ] && ${csudo} ln -s ${bin_dir}/taosdemo ${bin_link_dir}/taosdemo || :
-    [ -x ${bin_dir}/taosdump ] && ${csudo} ln -s ${bin_dir}/taosdump ${bin_link_dir}/taosdump || :
    [ -x ${bin_dir}/set_core.sh ] && ${csudo} ln -s ${bin_dir}/set_core.sh ${bin_link_dir}/set_core || :
 }
+function add_newHostname_to_hosts() {
+  localIp="127.0.0.1"
+  OLD_IFS="$IFS"
+  IFS=" "
+  iphost=$(cat /etc/hosts | grep $1 | awk '{print $1}')
+  arr=($iphost)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+    if [[ "$s" == "$localIp" ]]; then
+      return
+    fi
+  done 
+  ${csudo} echo "127.0.0.1  $1" >> /etc/hosts   ||:
+}
+function set_hostname() {
+  echo -e -n "${GREEN}Please enter one hostname(must not be 'localhost')${NC}:"
+	read newHostname
+  while true; do
+    if [[ ! -z "$newHostname" && "$newHostname" != "localhost" ]]; then
+      break
+    else
+      read -p "Please enter one hostname(must not be 'localhost'):" newHostname
+    fi
+  done
+  ${csudo} hostname $newHostname ||:
+  retval=`echo $?`
+  if [[ $retval != 0 ]]; then
+   echo
+   echo "set hostname fail!"
+   return 
+  fi
+  #echo -e -n "$(hostnamectl status --static)"
+  #echo -e -n "$(hostnamectl status --transient)"
+  #echo -e -n "$(hostnamectl status --pretty)"
+  #ubuntu/centos /etc/hostname
+  if [[ -e /etc/hostname ]]; then
+    ${csudo} echo $newHostname > /etc/hostname   ||:
+  fi
+  #debian: #HOSTNAME=yourname
+  if [[ -e /etc/sysconfig/network ]]; then
+    ${csudo} sed -i -r "s/#*\s*(HOSTNAME=\s*).*/\1$newHostname/" /etc/sysconfig/network   ||:
+  fi
+  ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$newHostname/" ${cfg_install_dir}/taos.cfg
+  serverFqdn=$newHostname  
+  if [[ -e /etc/hosts ]]; then
+    add_newHostname_to_hosts $newHostname
+  fi
+}
+function is_correct_ipaddr() {
+  newIp=$1
+  OLD_IFS="$IFS"
+  IFS=" "
+  arr=($iplist)
+  IFS="$OLD_IFS"
+  for s in ${arr[@]}
+  do
+   if [[ "$s" == "$newIp" ]]; then
+     return 0
+   fi
+  done
+  return 1
+}
+function set_ipAsFqdn() {
+  iplist=$(ip address |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F "/" '{print $1}') ||:
+  if [ -z "$iplist" ]; then
+    iplist=$(ifconfig |grep inet |grep -v inet6 |grep -v 127.0.0.1 |awk '{print $2}' |awk -F ":" '{print $2}') ||:
+  fi
+  if [ -z "$iplist" ]; then
+    echo
+    echo -e -n "${GREEN}Unable to get local ip, use 127.0.0.1${NC}"
+    localFqdn="127.0.0.1"
+    # Write the local FQDN to configuration file                    
+    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+    serverFqdn=$localFqdn
+    echo
+    return
+  fi  
+  echo -e -n "${GREEN}Please choose an IP from local IP list${NC}:"
+  echo
+  echo -e -n "${GREEN}$iplist${NC}"
+  echo
+  echo
+  echo -e -n "${GREEN}Notes: if IP is used as the node name, data can NOT be migrated to other machine directly${NC}:"
+  read localFqdn
+    while true; do
+      if [ ! -z "$localFqdn" ]; then            
+        # Check if correct ip address
+        is_correct_ipaddr $localFqdn
+        retval=`echo $?`
+        if [[ $retval != 0 ]]; then
+          read -p "Please choose an IP from local IP list:" localFqdn
+        else
+          # Write the local FQDN to configuration file                    
+          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+          serverFqdn=$localFqdn
+          break
+        fi
+      else
+        read -p "Please choose an IP from local IP list:" localFqdn
+      fi
+    done
+}
+function local_fqdn_check() {
+  #serverFqdn=$(hostname -f)
+  echo
+  echo -e -n "System hostname is: ${GREEN}$serverFqdn${NC}"
+  echo
+  if [[ "$serverFqdn" == "" ]] || [[ "$serverFqdn" == "localhost"  ]]; then    
+    echo -e -n "${GREEN}It is strongly recommended to configure a hostname for this machine ${NC}"
+    echo
+    while true
+    do
+	    read -r -p "Set hostname now? [Y/n] " input
+	    if [ ! -n "$input" ]; then
+       set_hostname
+       break
+      else
+	      case $input in
+	        [yY][eE][sS]|[yY])
+          set_hostname
+          break
+			    ;;
+	        [nN][oO]|[nN])
+			    set_ipAsFqdn
+			    break   	
+			    ;;
+	        *)
+			    echo "Invalid input..."
+			    ;;
+	      esac
+	    fi
+    done
+  fi
+}
 function install_config() {
    if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
        ${csudo} ${csudo} mkdir -p ${cfg_install_dir}
@@ -113,6 +266,8 @@ function install_config() {
        ${csudo} chmod 644 ${cfg_install_dir}/*
    fi
+    local_fqdn_check
    ${csudo} mv ${cfg_dir}/taos.cfg ${cfg_dir}/taos.cfg.org
    ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${cfg_dir}
    #FQDN_FORMAT="(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
@@ -130,19 +285,19 @@ function install_config() {
    	read firstEp;
 	fi
 	while true; do
-        if [ ! -z "$firstEp" ]; then
+    if [ ! -z "$firstEp" ]; then
-            # check the format of the firstEp
+        # check the format of the firstEp
-            #if [[ $firstEp == $FQDN_PATTERN ]]; then
+        #if [[ $firstEp == $FQDN_PATTERN ]]; then
-                # Write the first FQDN to configuration file                    
+            # Write the first FQDN to configuration file                    
-                ${csudo} sed -i -r "s/#*\s*(firstEp\s*).*/\1$firstEp/" ${cfg_install_dir}/taos.cfg    
+            ${csudo} sed -i -r "s/#*\s*(firstEp\s*).*/\1$firstEp/" ${cfg_install_dir}/taos.cfg    
-                break
-            #else
-            #    read -p "Please enter the correct FQDN:port: " firstEp
-            #fi
-        else
            break
-        fi
+        #else
-    done		
+        #    read -p "Please enter the correct FQDN:port: " firstEp
+        #fi
+    else
+        break
+    fi
+  done		
    # user email 
    #EMAIL_PATTERN='^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$'
@@ -300,18 +455,32 @@ function install_TDengine() {
        echo -e "${GREEN_DARK}To start TDengine     ${NC}: ./taosd${NC}"
    fi
-    echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
    if [ ! -z "$firstEp" ]; then
-        echo		    
+      tmpFqdn=${firstEp%%:*}
-	echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp${GREEN_DARK} to login into cluster, then${NC}"
+      substr=":"
-	echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+      if [[ $firstEp =~ $substr ]];then
-        echo
+        tmpPort=${firstEp#*:}
-    fi
+      else
+        tmpPort=""
+      fi
+      if [[ "$tmpPort" != "" ]];then
+	      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+	    else
+	      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+	    fi
+	    echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+      echo
+    elif [ ! -z "$serverFqdn" ]; then
+	    echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $serverFqdn${GREEN_DARK} to login into TDengine server${NC}"
+      echo
+    fi    
    echo
    echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
 }
 ## ==============================Main program starts from here============================
+serverFqdn=$(hostname -f)
 install_TDengine
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
 name: tdengine
 base: core18
-version: '2.0.9.0'
+version: '2.0.11.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
      - usr/bin/taosd
      - usr/bin/taos
      - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.9.0
+      - usr/lib/libtaos.so.2.0.11.0
      - usr/lib/libtaos.so.1
      - usr/lib/libtaos.so

--- a/src/client/inc/tscLog.h
+++ b/src/client/inc/tscLog.h
@@ -22,16 +22,16 @@ extern "C" {
 #include "tlog.h"
-extern int32_t cDebugFlag;
+extern uint32_t cDebugFlag;
-extern int32_t tscEmbedded;
+extern uint32_t tscEmbedded;
-#define tscFatal(...) { if (cDebugFlag & DEBUG_FATAL) { taosPrintLog("TSC FATAL ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}
+#define tscFatal(...)  do { if (cDebugFlag & DEBUG_FATAL) { taosPrintLog("TSC FATAL ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscError(...) { if (cDebugFlag & DEBUG_ERROR) { taosPrintLog("TSC ERROR ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}
+#define tscError(...)  do { if (cDebugFlag & DEBUG_ERROR) { taosPrintLog("TSC ERROR ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscWarn(...)  { if (cDebugFlag & DEBUG_WARN)  { taosPrintLog("TSC WARN ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}
+#define tscWarn(...)   do { if (cDebugFlag & DEBUG_WARN)  { taosPrintLog("TSC WARN ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}  while(0)
-#define tscInfo(...)  { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }}
+#define tscInfo(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", tscEmbedded ? 255 : cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscDebug(...) { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscDebug(...)  do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscTrace(...) { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscTrace(...)  do { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscDebugL(...){ if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscDebugL(...) do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
 #ifdef __cplusplus
 }

--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -36,7 +36,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql);
 int32_t tscHandleMultivnodeInsert(SSqlObj *pSql);
-int32_t tscHandleInsertRetry(SSqlObj* pSql);
+int32_t tscHandleInsertRetry(SSqlObj* parent, SSqlObj* child);
 void tscBuildResFromSubqueries(SSqlObj *pSql);
 TAOS_ROW doSetResultRowData(SSqlObj *pSql);

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -110,11 +110,12 @@ SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint
                                   uint32_t offset);
 void*   tscDestroyBlockArrayList(SArray* pDataBlockList);
+void*   tscDestroyBlockHashTable(SHashObj* pBlockHashTable);
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
-int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pDataList);
+int32_t tscMergeTableDataBlocks(SSqlObj* pSql);
-int32_t tscGetDataBlockFromList(void* pHashList, SArray* pDataBlockList, int64_t id, int32_t size,
+int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
-                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
+                                STableDataBlocks** dataBlocks, SArray* pBlockList);
-                                STableDataBlocks** dataBlocks);
 /**
 * for the projection query on metric or point interpolation query on metric,
@@ -233,7 +234,7 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
 int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
-int  tscGetMeterMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
+int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 void tscResetForNextRetrieve(SSqlRes* pRes);
 void tscDoQuery(SSqlObj* pSql);
@@ -275,6 +276,8 @@ void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex);
 bool hasMoreVnodesToTry(SSqlObj *pSql);
 bool hasMoreClauseToTry(SSqlObj* pSql);
+void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeFromCache);
 void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
@@ -284,6 +287,9 @@ bool tscSetSqlOwner(SSqlObj* pSql);
 void tscClearSqlOwner(SSqlObj* pSql);
 int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize);
+char*   serializeTagData(STagData* pTagData, char* pMsg);
+int32_t copyTagData(STagData* dst, const STagData* src);
 void* malloc_throw(size_t size);
 void* calloc_throw(size_t nmemb, size_t size);
 char* strdup_throw(const char* str);

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -37,40 +37,6 @@ extern "C" {
 #include "qTsbuf.h"
 #include "tcmdtype.h"
-#if 0
-static UNUSED_FUNC void *u_malloc (size_t __size) {
-  uint32_t v = rand();
-  if (v % 5000 <= 0) {
-    return NULL;
-  } else {
-    return malloc(__size);
-  }
-}
-static UNUSED_FUNC void* u_calloc(size_t num, size_t __size) {
-  uint32_t v = rand();
-  if (v % 5000 <= 0) {
-    return NULL;
-  } else {
-    return calloc(num, __size);
-  }
-}
-static UNUSED_FUNC void* u_realloc(void* p, size_t __size) {
-  uint32_t v = rand();
-  if (v % 5000 <= 0) {
-    return NULL;
-  } else {
-    return realloc(p, __size);
-  }
-}
-#define calloc  u_calloc
-#define malloc  u_malloc
-#define realloc u_realloc
-#endif
 // forward declaration
 struct SSqlInfo;
 struct SLocalReducer;
@@ -78,7 +44,7 @@ struct SLocalReducer;
 // data source from sql string or from file
 enum {
  DATA_FROM_SQL_STRING = 1,
-  DATA_FROM_DATA_FILE = 2,
+  DATA_FROM_DATA_FILE  = 2,
 };
 typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int32_t numOfRows);
@@ -118,10 +84,10 @@ typedef struct STableMetaInfo {
   * 1. keep the vgroup index during the multi-vnode super table projection query
   * 2. keep the vgroup index for multi-vnode insertion
   */
-  int32_t vgroupIndex;
+  int32_t       vgroupIndex;
-  char    name[TSDB_TABLE_FNAME_LEN];        // (super) table name
+  char          name[TSDB_TABLE_FNAME_LEN];        // (super) table name
-  char    aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
+  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
-  SArray* tagColList;                        // SArray<SColumn*>, involved tag columns
+  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
 } STableMetaInfo;
 /* the structure for sql function in select clause */
@@ -136,7 +102,7 @@ typedef struct SSqlExpr {
  int16_t   numOfParams;    // argument value of each function
  tVariant  param[3];       // parameters are not more than 3
  int32_t   offset;         // sub result column value of arithmetic expression.
-  int16_t   resColId;          // result column id
+  int16_t   resColId;       // result column id
 } SSqlExpr;
 typedef struct SColumnIndex {
@@ -204,22 +170,17 @@ typedef struct SParamInfo {
 } SParamInfo;
 typedef struct STableDataBlocks {
-  char     tableId[TSDB_TABLE_FNAME_LEN];
+  char        tableId[TSDB_TABLE_FNAME_LEN];
-  int8_t   tsSource;     // where does the UNIX timestamp come from, server or client
+  int8_t      tsSource;     // where does the UNIX timestamp come from, server or client
-  bool     ordered;      // if current rows are ordered or not
+  bool        ordered;      // if current rows are ordered or not
-  int64_t  vgId;         // virtual group id
+  int64_t     vgId;         // virtual group id
-  int64_t  prevTS;       // previous timestamp, recorded to decide if the records array is ts ascending
+  int64_t     prevTS;       // previous timestamp, recorded to decide if the records array is ts ascending
-  int32_t  numOfTables;  // number of tables in current submit block
+  int32_t     numOfTables;  // number of tables in current submit block
-  int32_t  rowSize;      // row size for current table
+  int32_t     rowSize;      // row size for current table
-  uint32_t nAllocSize;
+  uint32_t    nAllocSize;
-  uint32_t headerSize;   // header for table info (uid, tid, submit metadata)
+  uint32_t    headerSize;   // header for table info (uid, tid, submit metadata)
-  uint32_t size;
+  uint32_t    size;
+  STableMeta *pTableMeta;   // the tableMeta of current table, the table meta will be used during submit, keep a ref to avoid to be removed from cache
-  /*
-   * the table meta of table, the table meta will be used during submit, keep a ref
-   * to avoid it to be removed from cache
-   */
-  STableMeta *pTableMeta;
  char       *pData;
  // for parameter ('?') binding
@@ -252,7 +213,7 @@ typedef struct SQueryInfo {
  int64_t          clauseLimit;   // limit for current sub clause
  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
-  int64_t          tableLimit;    // table limit in case of super table projection query + global order + limit
+  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
  int16_t          resColumnId;   // result column id
@@ -268,7 +229,7 @@ typedef struct {
    int32_t numOfTablesInSubmit;
  };
-  int32_t      insertType;
+  uint32_t     insertType;
  int32_t      clauseIndex;  // index of multiple subclause query
  char *       curSql;       // current sql, resume position of sql after parsing paused
@@ -284,10 +245,14 @@ typedef struct {
  int32_t      numOfParams;
  int8_t       dataSourceType;     // load data from file or not
-  int8_t       submitSchema; // submit block is built with table schema
+  int8_t       submitSchema;   // submit block is built with table schema
-  STagData    *pTagData;     // NOTE: pTagData->data is used as a variant length array
+  STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
-  SHashObj    *pTableList;   // referred table involved in sql
-  SArray      *pDataBlocks;  // SArray<STableDataBlocks*> submit data blocks after parsing sql
+  STableMeta **pTableMetaList; // all involved tableMeta list of current insert sql statement.
+  int32_t      numOfTables;
+  SHashObj    *pTableBlockHashList;     // data block for each table
+  SArray      *pDataBlocks;    // SArray<STableDataBlocks*>. Merged submit block for each vgroup
 } SSqlCmd;
 typedef struct SResRec {
@@ -320,8 +285,8 @@ typedef struct {
  char **        buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
  SColumnIndex*  pColumnIndex;
-  SArithmeticSupport*   pArithSup;   // support the arithmetic expression calculation on agg functions
+  SArithmeticSupport   *pArithSup;   // support the arithmetic expression calculation on agg functions
-  struct SLocalReducer* pLocalReducer;
+  struct SLocalReducer *pLocalReducer;
 } SSqlRes;
 typedef struct STscObj {
@@ -382,6 +347,7 @@ typedef struct SSqlObj {
 typedef struct SSqlStream {
  SSqlObj *pSql;
+  const char* dstTable;
  uint32_t streamId;
  char     listed;
  bool     isProject;
@@ -408,6 +374,8 @@ typedef struct SSqlStream {
  struct SSqlStream *prev, *next;
 } SSqlStream;
+void tscSetStreamDestTable(SSqlStream* pStream, const char* dstTable);
 int32_t tscInitRpc(const char *user, const char *secret, void** pDnodeConn);
 void    tscInitMsgsFp();

--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -365,6 +365,7 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
 static void tscProcessAsyncError(SSchedMsg *pMsg) {
  void (*fp)() = pMsg->ahandle;
  terrno = *(int32_t*) pMsg->msg;
+  tfree(pMsg->msg);
  (*fp)(pMsg->thandle, NULL, *(int32_t*)pMsg->msg);
 }
@@ -380,6 +381,7 @@ void tscQueueAsyncError(void(*fp), void *param, int32_t code) {
  taosScheduleTask(tscQhandle, &schedMsg);
 }
 void tscQueueAsyncRes(SSqlObj *pSql) {
  if (pSql == NULL || pSql->signature != pSql) {
    tscDebug("%p SqlObj is freed, not add into queue async res", pSql);
@@ -389,7 +391,10 @@ void tscQueueAsyncRes(SSqlObj *pSql) {
  tscError("%p add into queued async res, code:%s", pSql, tstrerror(pSql->res.code));
  SSqlRes *pRes = &pSql->res;
-  assert(pSql->fp != NULL && pSql->fetchFp != NULL);
+  if (pSql->fp == NULL || pSql->fetchFp == NULL){
+    return;
+  }
  pSql->fp = pSql->fetchFp;
  (*pSql->fp)(pSql->param, pSql, pRes->code);
@@ -410,52 +415,26 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
  if (code != TSDB_CODE_SUCCESS) {
    tscError("%p get %s failed, code:%s", pSql, msg, tstrerror(code));
    goto _error;
-  } else {
-    tscDebug("%p get %s successfully", pSql, msg);
  }
+  tscDebug("%p get %s successfully", pSql, msg);
  if (pSql->pStream == NULL) {
    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
    // check if it is a sub-query of super table query first, if true, enter another routine
-    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY)) {
+    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
-      tscDebug("%p update table meta in local cache, continue to process sql and send corresponding subquery", pSql);
+      tscDebug("%p update table meta in local cache, continue to process sql and send the corresponding query", pSql);
      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
      code = tscGetTableMeta(pSql, pTableMetaInfo);
-      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+      assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
-        return;
-      } else {
-        assert(code == TSDB_CODE_SUCCESS);      
-      }
-      // param already freed by other routine and pSql in tscCache when ctrl + c 
-      if (atomic_load_ptr(&pSql->param) == NULL) {
-        return;
-      }
-      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));
-      SRetrieveSupport *trs = (SRetrieveSupport *)pSql->param;
-      SSqlObj *         pParObj = trs->pParentSql;
-      // NOTE: the vgroupInfo for the queried super table must be existed here.
-      assert(pParObj->signature == pParObj && trs->subqueryIndex == pTableMetaInfo->vgroupIndex &&
-          pTableMetaInfo->vgroupIndex >= 0 && pTableMetaInfo->vgroupList != NULL);
-      // tscProcessSql can add error into async res
-      tscProcessSql(pSql);
-      return;
-    } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) {
-      tscDebug("%p update table meta in local cache, continue to process sql and send corresponding tid_tag query", pSql);
-      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-      code = tscGetTableMeta(pSql, pTableMetaInfo);
      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
        return;
-      } else {
-        assert(code == TSDB_CODE_SUCCESS);
      }
      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));
      // tscProcessSql can add error into async res
      tscProcessSql(pSql);
      return;
@@ -465,16 +444,15 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
        code = tscGetTableMeta(pSql, pTableMetaInfo);
+        assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
          return;
-        } else {
-          assert(code == TSDB_CODE_SUCCESS);      
        }
-        // in case of insert, redo parsing the sql string and build new submit data block for two reasons:
+        assert(pCmd->command != TSDB_SQL_INSERT);
-        // 1. the table Id(tid & uid) may have been update, the submit block needs to be updated accordingly.
-        // 2. vnode may need the schema information along with submit block to update its local table schema.
+        if (pCmd->command == TSDB_SQL_SELECT) {
-        if (pCmd->command == TSDB_SQL_INSERT || pCmd->command == TSDB_SQL_SELECT) {
          tscDebug("%p redo parse sql string and proceed", pSql);
          pCmd->parseFinished = false;
          tscResetSqlCmdObj(pCmd, false);
@@ -486,17 +464,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
            goto _error;
          }
-          if (pCmd->command == TSDB_SQL_INSERT) {
+          tscProcessSql(pSql);
-            /*
+        } else {  // in all other cases, simple retry
-             * Discard previous built submit blocks, and then parse the sql string again and build up all submit blocks,
-             * and send the required submit block according to index value in supporter to server.
-             */
-            pSql->fp = pSql->fetchFp;  // restore the fp
-            tscHandleInsertRetry(pSql);
-          } else if (pCmd->command == TSDB_SQL_SELECT) {  // in case of other query type, continue
-            tscProcessSql(pSql);
-          }
-        }else {  // in all other cases, simple retry
          tscProcessSql(pSql);
        }
@@ -551,6 +520,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    if (!pSql->cmd.parseFinished) {
      tsParseSql(pSql, false);
    }
    (*pSql->fp)(pSql->param, pSql, code);
    return;

--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -48,7 +48,7 @@
      break;                             \
    }                                    \
    GET_RES_INFO(ctx)->numOfRes = (res); \
-  } while (0);
+  } while (0)
 #define INC_INIT_VAL(ctx, res) (GET_RES_INFO(ctx)->numOfRes += (res));
@@ -482,17 +482,16 @@ int32_t no_data_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32_t colId
      DO_UPDATE_TAG_COLUMNS(ctx, k);                \
      (num) += 1;                                   \
    }                                               \
-  } while (0);
+  } while (0)
 #define DUPATE_DATA_WITHOUT_TS(ctx, left, right, num, sign) \
-do {                                              \
+  do {                                                      \
-    if (((left) < (right)) ^ (sign)) {              \
+    if (((left) < (right)) ^ (sign)) {                      \
-      (left) = (right);                             \
+      (left) = (right);                                     \
      DO_UPDATE_TAG_COLUMNS_WITHOUT_TS(ctx);                \
-      (num) += 1;                                   \
+      (num) += 1;                                           \
-    }                                               \
+    }                                                       \
-  } while (0);
+  } while (0)
 #define LOOPCHECK_N(val, list, ctx, tsdbType, sign, num)          \
  for (int32_t i = 0; i < ((ctx)->size); ++i) {                   \
@@ -709,15 +708,14 @@ static int32_t firstDistFuncRequired(SQLFunctionCtx *pCtx, TSKEY start, TSKEY en
    return BLK_DATA_ALL_NEEDED;
  }
-  return BLK_DATA_ALL_NEEDED;
+  // the pCtx should be set to current Ctx and output buffer before call this function. Otherwise, pCtx->aOutputBuf is
-  // TODO pCtx->aOutputBuf is the previous windowRes output buffer, not current unloaded block. so the following filter
+  // the previous windowRes output buffer, not current unloaded block. In this case, the following filter is invalid
-  // is invalid
+  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
-//  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
+  if (pInfo->hasResult != DATA_SET_FLAG) {
-//  if (pInfo->hasResult != DATA_SET_FLAG) {
+    return BLK_DATA_ALL_NEEDED;
-//    return BLK_DATA_ALL_NEEDED;
+  } else {  // data in current block is not earlier than current result
-//  } else {  // data in current block is not earlier than current result
+    return (pInfo->ts <= start) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
-//    return (pInfo->ts <= start) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
+  }
-//  }
 }
 static int32_t lastDistFuncRequired(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32_t colId) {
@@ -730,16 +728,14 @@ static int32_t lastDistFuncRequired(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end
    return BLK_DATA_ALL_NEEDED;
  }
-  return BLK_DATA_ALL_NEEDED;
+  // the pCtx should be set to current Ctx and output buffer before call this function. Otherwise, pCtx->aOutputBuf is
-  // TODO pCtx->aOutputBuf is the previous windowRes output buffer, not current unloaded block. so the following filter
+  // the previous windowRes output buffer, not current unloaded block. In this case, the following filter is invalid
-  // is invalid
+  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
+  if (pInfo->hasResult != DATA_SET_FLAG) {
-//  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
+    return BLK_DATA_ALL_NEEDED;
-//  if (pInfo->hasResult != DATA_SET_FLAG) {
+  } else {
-//    return BLK_DATA_ALL_NEEDED;
+    return (pInfo->ts > end) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
-//  } else {
+  }
-//    return (pInfo->ts > end) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
-//  }
 }
 //////////////////////////////////////////////////////////////////////////////////////////////
@@ -1909,7 +1905,7 @@ static void valuePairAssign(tValuePair *dst, int16_t type, const char *val, int6
    (dst)->timestamp = (src)->timestamp;               \
    (dst)->v = (src)->v;                               \
    memcpy((dst)->pTags, (src)->pTags, (size_t)(__l)); \
-  } while (0);
+  } while (0)
 static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData, int64_t ts, uint16_t type,
                                SExtTagsInfo *pTagInfo, char *pTags, int16_t stage) {
@@ -2222,7 +2218,8 @@ static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
  tmp += POINTER_BYTES * pCtx->param[0].i64Key;
  size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
+//  assert(pCtx->param[0].i64Key > 0);
  for (int32_t i = 0; i < pCtx->param[0].i64Key; ++i) {
    pTopBotInfo->res[i] = (tValuePair*) tmp;
    pTopBotInfo->res[i]->pTags = tmp + sizeof(tValuePair);
@@ -2589,10 +2586,11 @@ static void percentile_next_step(SQLFunctionCtx *pCtx) {
    // all data are null, set it completed
    if (pInfo->numOfElems == 0) {
      pResInfo->complete = true;
+    } else {
+      pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, GET_DOUBLE_VAL(&pInfo->minval), GET_DOUBLE_VAL(&pInfo->maxval));
    }
    pInfo->stage += 1;
-    pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, GET_DOUBLE_VAL(&pInfo->minval), GET_DOUBLE_VAL(&pInfo->maxval));
  } else {
    pResInfo->complete = true;
  }
@@ -2883,7 +2881,7 @@ static void leastsquares_function_f(SQLFunctionCtx *pCtx, int32_t index) {
      int32_t *p = pData;
      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
      break;
-    };
+    }
    case TSDB_DATA_TYPE_TINYINT: {
      int8_t *p = pData;
      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
@@ -3647,11 +3645,21 @@ static bool twa_function_setup(SQLFunctionCtx *pCtx) {
  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
  STwaInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-  pInfo->lastKey  = INT64_MIN;
+  pInfo->p.key    = INT64_MIN;
  pInfo->win      = TSWINDOW_INITIALIZER;
  return true;
 }
+static double twa_get_area(SPoint1 s, SPoint1 e) {
+  if ((s.val >= 0 && e.val >= 0)|| (s.val <=0 && e.val <= 0)) {
+    return (s.val + e.val) * (e.key - s.key) / 2;
+  }
+  double x = (s.key * e.val - e.key * s.val)/(e.val - s.val);
+  double val = (s.val * (x - s.key) + e.val * (e.key - x)) / 2;
+  return val;
+}
 static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t index, int32_t size) {
  int32_t notNullElems = 0;
  TSKEY *primaryKey = pCtx->ptsList;
@@ -3662,28 +3670,29 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
  int32_t i = index;
  int32_t step = GET_FORWARD_DIRECTION_FACTOR(pCtx->order);
+  SPoint1* last = &pInfo->p;
  if (pCtx->start.key != INT64_MIN) {
    assert((pCtx->start.key < primaryKey[tsIndex + i] && pCtx->order == TSDB_ORDER_ASC) ||
               (pCtx->start.key > primaryKey[tsIndex + i] && pCtx->order == TSDB_ORDER_DESC));
-    assert(pInfo->lastKey == INT64_MIN);
+    assert(last->key == INT64_MIN);
-    pInfo->lastKey = primaryKey[tsIndex + i];
+    last->key = primaryKey[tsIndex + i];
-    GET_TYPED_DATA(pInfo->lastValue, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
+    GET_TYPED_DATA(last->val, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
-    pInfo->dOutput += ((pInfo->lastValue + pCtx->start.val) / 2) * (pInfo->lastKey - pCtx->start.key);
+    pInfo->dOutput += twa_get_area(pCtx->start, *last);
    pInfo->hasResult = DATA_SET_FLAG;
    pInfo->win.skey = pCtx->start.key;
    notNullElems++;
    i += step;
-  } else if (pInfo->lastKey == INT64_MIN) {
+  } else if (pInfo->p.key == INT64_MIN) {
-    pInfo->lastKey = primaryKey[tsIndex + i];
+    last->key = primaryKey[tsIndex + i];
-    GET_TYPED_DATA(pInfo->lastValue, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
+    GET_TYPED_DATA(last->val, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
    pInfo->hasResult = DATA_SET_FLAG;
-    pInfo->win.skey = pInfo->lastKey;
+    pInfo->win.skey = last->key;
    notNullElems++;
    i += step;
  }
@@ -3697,9 +3706,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3710,9 +3719,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3723,9 +3732,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3736,9 +3745,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = (double) val[i]};
-        pInfo->lastValue = (double) val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3749,9 +3758,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3762,9 +3771,9 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + tsIndex] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + tsIndex], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + tsIndex];
+        pInfo->p = st;
      }
      break;
    }
@@ -3773,20 +3782,19 @@ static int32_t twa_function_impl(SQLFunctionCtx* pCtx, int32_t tsIndex, int32_t
  // the last interpolated time window value
  if (pCtx->end.key != INT64_MIN) {
-    pInfo->dOutput  += ((pInfo->lastValue + pCtx->end.val) / 2) * (pCtx->end.key - pInfo->lastKey);
+    pInfo->dOutput  += twa_get_area(pInfo->p, pCtx->end);
-    pInfo->lastValue = pCtx->end.val;
+    pInfo->p = pCtx->end;
-    pInfo->lastKey   = pCtx->end.key;
  }
-  pInfo->win.ekey  = pInfo->lastKey;
+  pInfo->win.ekey  = pInfo->p.key;
  return notNullElems;
 }
 static void twa_function(SQLFunctionCtx *pCtx) {
-  void * data = GET_INPUT_CHAR(pCtx);
+  void *data = GET_INPUT_CHAR(pCtx);
  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-  STwaInfo *   pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  STwaInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
  // skip null value
  int32_t step = GET_FORWARD_DIRECTION_FACTOR(pCtx->order);
@@ -3807,6 +3815,7 @@ static void twa_function(SQLFunctionCtx *pCtx) {
  }
 }
+//TODO refactor
 static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
  void *pData = GET_INPUT_CHAR_INDEX(pCtx, index);
  if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
@@ -3823,23 +3832,23 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
  int32_t size = pCtx->size;
  if (pCtx->start.key != INT64_MIN) {
-    assert(pInfo->lastKey == INT64_MIN);
+    assert(pInfo->p.key == INT64_MIN);
-    pInfo->lastKey = primaryKey[index];
+    pInfo->p.key = primaryKey[index];
-    GET_TYPED_DATA(pInfo->lastValue, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
+    GET_TYPED_DATA(pInfo->p.val, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
-    pInfo->dOutput += ((pInfo->lastValue + pCtx->start.val) / 2) * (pInfo->lastKey - pCtx->start.key);
+    pInfo->dOutput += twa_get_area(pCtx->start, pInfo->p);
    pInfo->hasResult = DATA_SET_FLAG;
    pInfo->win.skey = pCtx->start.key;
    notNullElems++;
    i += 1;
-  } else if (pInfo->lastKey == INT64_MIN) {
+  } else if (pInfo->p.key == INT64_MIN) {
-    pInfo->lastKey = primaryKey[index];
+    pInfo->p.key = primaryKey[index];
-    GET_TYPED_DATA(pInfo->lastValue, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
+    GET_TYPED_DATA(pInfo->p.val, double, pCtx->inputType, GET_INPUT_CHAR_INDEX(pCtx, index));
    pInfo->hasResult = DATA_SET_FLAG;
-    pInfo->win.skey = pInfo->lastKey;
+    pInfo->win.skey = pInfo->p.key;
    notNullElems++;
    i += 1;
  }
@@ -3853,9 +3862,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3866,9 +3875,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3879,9 +3888,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3892,9 +3901,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = (double) val[i]};
-        pInfo->lastValue = (double) val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3905,9 +3914,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);//((val[i] + pInfo->p.val) / 2) * (primaryKey[i + index] - pInfo->p.key);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3918,9 +3927,9 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
          continue;
        }
-        pInfo->dOutput += ((val[i] + pInfo->lastValue) / 2) * (primaryKey[i + index] - pInfo->lastKey);
+        SPoint1 st = {.key = primaryKey[i + index], .val = val[i]};
-        pInfo->lastValue = val[i];
+        pInfo->dOutput += twa_get_area(pInfo->p, st);//((val[i] + pInfo->p.val) / 2) * (primaryKey[i + index] - pInfo->p.key);
-        pInfo->lastKey = primaryKey[i + index];
+        pInfo->p = st;
      }
      break;
    }
@@ -3929,12 +3938,11 @@ static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
  // the last interpolated time window value
  if (pCtx->end.key != INT64_MIN) {
-    pInfo->dOutput  += ((pInfo->lastValue + pCtx->end.val) / 2) * (pCtx->end.key - pInfo->lastKey);
+    pInfo->dOutput  += twa_get_area(pInfo->p, pCtx->end);//((pInfo->p.val + pCtx->end.val) / 2) * (pCtx->end.key - pInfo->p.key);
-    pInfo->lastValue = pCtx->end.val;
+    pInfo->p = pCtx->end;
-    pInfo->lastKey   = pCtx->end.key;
  }
-  pInfo->win.ekey  = pInfo->lastKey;
+  pInfo->win.ekey  = pInfo->p.key;
  SET_VAL(pCtx, notNullElems, 1);
@@ -3965,7 +3973,7 @@ static void twa_func_merge(SQLFunctionCtx *pCtx) {
    pBuf->dOutput += pInput->dOutput;
    pBuf->win = pInput->win;
-    pBuf->lastKey = pInput->lastKey;
+    pBuf->p   = pInput->p;
  }
  SET_VAL(pCtx, numOfNotNull, 1);
@@ -3992,15 +4000,14 @@ void twa_function_finalizer(SQLFunctionCtx *pCtx) {
  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
  STwaInfo *pInfo = (STwaInfo *)GET_ROWCELL_INTERBUF(pResInfo);
-  assert(pInfo->win.ekey == pInfo->lastKey && pInfo->hasResult == pResInfo->hasResult);
  if (pInfo->hasResult != DATA_SET_FLAG) {
    setNull(pCtx->aOutputBuf, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
    return;
  }
+  assert(pInfo->win.ekey == pInfo->p.key && pInfo->hasResult == pResInfo->hasResult);
  if (pInfo->win.ekey == pInfo->win.skey) {
-    *(double *)pCtx->aOutputBuf = pInfo->lastValue;
+    *(double *)pCtx->aOutputBuf = pInfo->p.val;
  } else {
    *(double *)pCtx->aOutputBuf = pInfo->dOutput / (pInfo->win.ekey - pInfo->win.skey);
  }

--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -46,7 +46,8 @@ typedef struct SCreateBuilder {
  SSqlObj *pInterSql;
  int32_t (*fp)(void *para, char* result);
  Stage callStage;
-} SCreateBuilder; 
+} SCreateBuilder;
 static void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnName, int16_t type, size_t valueLength);
 static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
@@ -207,10 +208,7 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
  const int32_t TYPE_COLUMN_LENGTH = 16;
  const int32_t NOTE_COLUMN_MIN_LENGTH = 8;
-  int32_t noteFieldLen = NOTE_COLUMN_MIN_LENGTH;//tscMaxLengthOfTagsFields(pSql);
+  int32_t noteFieldLen = NOTE_COLUMN_MIN_LENGTH;
-//  if (noteFieldLen == 0) {
-//    noteFieldLen = NOTE_COLUMN_MIN_LENGTH;
-//  }
  int32_t rowLen = tscBuildTableSchemaResultFields(pSql, NUM_OF_DESC_TABLE_COLUMNS, TYPE_COLUMN_LENGTH, noteFieldLen);
  tscFieldInfoUpdateOffset(pQueryInfo);
@@ -571,7 +569,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
  }
-  char fullName[TSDB_TABLE_FNAME_LEN] = {0};
+  char fullName[TSDB_TABLE_FNAME_LEN * 2] = {0};
  extractDBName(pTableMetaInfo->name, fullName);
  extractTableName(pMeta->sTableId, param->sTableName);
  snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName),  ".%s", param->sTableName);
@@ -822,26 +820,39 @@ static int32_t tscProcessClientVer(SSqlObj *pSql) {
 }
+// TODO add test cases.
+static int32_t checkForOnlineNode(SSqlObj* pSql) {
+  int32_t* data = pSql->res.length;
+  if (data == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+  int32_t total  = data[0];
+  int32_t online = data[1];
+  return (online < total)? TSDB_CODE_RPC_NETWORK_UNAVAIL:TSDB_CODE_SUCCESS;
+}
 static int32_t tscProcessServStatus(SSqlObj *pSql) {
  STscObj* pObj = pSql->pTscObj;
  SSqlObj* pHb = (SSqlObj*)taosAcquireRef(tscObjRef, pObj->hbrid);
  if (pHb != NULL) {
-    int32_t code = pHb->res.code;
+    pSql->res.code = pHb->res.code;
    taosReleaseRef(tscObjRef, pObj->hbrid);
-    if (code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
-      pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
-      return pSql->res.code;
-    }
-  } else {
-    if (pSql->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
-      return pSql->res.code;
-    }
  }
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  if (pSql->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
+    return pSql->res.code;
+  }
+  pSql->res.code = checkForOnlineNode(pHb);
+  if (pSql->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
+    return pSql->res.code;
+  }
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
  int32_t val = 1;
  tscSetLocalQueryResult(pSql, (char*) &val, pExpr->aliasName, TSDB_DATA_TYPE_INT, sizeof(int32_t));
  return TSDB_CODE_SUCCESS;

--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -726,10 +726,14 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
    SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
    SSchema p1 = {0};
-    if (pExpr->colInfo.colIndex != TSDB_TBNAME_COLUMN_INDEX) {
+    if (pExpr->colInfo.colIndex == TSDB_TBNAME_COLUMN_INDEX) {
-      p1 = *tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->colInfo.colIndex);
-    } else {
      p1 = tGetTableNameColumnSchema();
+    } else if (TSDB_COL_IS_UD_COL(pExpr->colInfo.flag)) {
+      p1.bytes = pExpr->resBytes;
+      p1.type  = (uint8_t) pExpr->resType;
+      tstrncpy(p1.name, pExpr->aliasName, tListLen(p1.name));
+    } else {
+      p1 = *tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->colInfo.colIndex);
    }
    int32_t inter = 0;

--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -686,17 +686,14 @@ void tscSortRemoveDataBlockDupRows(STableDataBlocks *dataBuf) {
  }
 }
-static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **str, SParsedDataColInfo *spd,
+static int32_t doParseInsertStatement(SSqlCmd* pCmd, char **str, SParsedDataColInfo *spd, int32_t *totalNum) {
-                                      int32_t *totalNum) {
-  SSqlCmd *       pCmd = &pSql->cmd;
  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-  STableMeta *    pTableMeta = pTableMetaInfo->pTableMeta;
+  STableMeta     *pTableMeta = pTableMetaInfo->pTableMeta;
  STableComInfo tinfo = tscGetTableInfo(pTableMeta);
  STableDataBlocks *dataBuf = NULL;
-  int32_t ret = tscGetDataBlockFromList(pTableList, pCmd->pDataBlocks, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
+  int32_t ret = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
-                                        sizeof(SSubmitBlk), tinfo.rowSize, pTableMetaInfo->name,
+                                        sizeof(SSubmitBlk), tinfo.rowSize, pTableMetaInfo->name, pTableMeta, &dataBuf, NULL);
-                                        pTableMeta, &dataBuf);
  if (ret != TSDB_CODE_SUCCESS) {
    return ret;
  }
@@ -799,8 +796,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
    sToken = tStrGetToken(sql, &index, false, 0, NULL);
    sql += index;
-    tscAllocPayload(pCmd, sizeof(STagData));
    //the source super table is moved to the secondary position of the pTableMetaInfo list
    if (pQueryInfo->numOfTables < 2) {
      tscAddEmptyMetaInfo(pQueryInfo);
@@ -812,13 +807,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
      return code;
    }
-    STagData *pTag = realloc(pCmd->pTagData, offsetof(STagData, data));
+    tstrncpy(pCmd->tagData.name, pSTableMeterMetaInfo->name, sizeof(pCmd->tagData.name));
-    if (pTag == NULL) {
+    pCmd->tagData.dataLen = 0;
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-    memset(pTag, 0, offsetof(STagData, data));
-    tstrncpy(pTag->name, pSTableMeterMetaInfo->name, sizeof(pTag->name));
-    pCmd->pTagData = pTag;
    code = tscGetTableMeta(pSql, pSTableMeterMetaInfo);
    if (code != TSDB_CODE_SUCCESS) {
@@ -949,14 +939,15 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
    }
    tdSortKVRowByColIdx(row);
-    pTag = (STagData*)realloc(pCmd->pTagData, offsetof(STagData, data) + kvRowLen(row));
+    pCmd->tagData.dataLen = kvRowLen(row);
+    char* pTag = realloc(pCmd->tagData.data, pCmd->tagData.dataLen);
    if (pTag == NULL) {
      return TSDB_CODE_TSC_OUT_OF_MEMORY;
    }
-    pCmd->pTagData = pTag;
-    pTag->dataLen = htonl(kvRowLen(row));
+    kvRowCpy(pTag, row);
-    kvRowCpy(pTag->data, row);
    free(row);
+    pCmd->tagData.data = pTag;
    index = 0;
    sToken = tStrGetToken(sql, &index, false, 0, NULL);
@@ -975,7 +966,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
    }
    createTable = true;
-    code = tscGetMeterMetaEx(pSql, pTableMetaInfo, true);
+    code = tscGetTableMetaEx(pSql, pTableMetaInfo, true);
    if (TSDB_CODE_TSC_ACTION_IN_PROGRESS == code) {
      return code;
    }
@@ -986,7 +977,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
    } else {
      sql = sToken.z;
    }
-    code = tscGetMeterMetaEx(pSql, pTableMetaInfo, false);
+    code = tscGetTableMetaEx(pSql, pTableMetaInfo, false);
    if (pCmd->curSql == NULL) {
      assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS);
@@ -1058,18 +1049,17 @@ int tsParseInsertSql(SSqlObj *pSql) {
    return code;
  }
-  if (NULL == pCmd->pTableList) {
+  if (NULL == pCmd->pTableBlockHashList) {
-    pCmd->pTableList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    pCmd->pTableBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
-    pCmd->pDataBlocks = taosArrayInit(4, POINTER_BYTES);
+    if (NULL == pCmd->pTableBlockHashList) {
-    if (NULL == pCmd->pTableList || NULL == pSql->cmd.pDataBlocks) {
      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-      goto _error;
+      goto _clean;
    }
  } else {
    str = pCmd->curSql;
  }
-  tscDebug("%p create data block list for submit data:%p, pTableList:%p", pSql, pCmd->pDataBlocks, pCmd->pTableList);
+  tscDebug("%p create data block list hashList:%p", pSql, pCmd->pTableBlockHashList);
  while (1) {
    int32_t   index = 0;
@@ -1091,7 +1081,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
       */
      if (totalNum == 0) {
        code = TSDB_CODE_TSC_INVALID_SQL;
-        goto _error;
+        goto _clean;
      } else {
        break;
      }
@@ -1104,11 +1094,11 @@ int tsParseInsertSql(SSqlObj *pSql) {
    // Check if the table name available or not
    if (validateTableName(sToken.z, sToken.n, &sTblToken) != TSDB_CODE_SUCCESS) {
      code = tscInvalidSQLErrMsg(pCmd->payload, "table name invalid", sToken.z);
-      goto _error;
+      goto _clean;
    }
    if ((code = tscSetTableFullName(pTableMetaInfo, &sTblToken, pSql)) != TSDB_CODE_SUCCESS) {
-      goto _error;
+      goto _clean;
    }
    if ((code = tscCheckIfCreateTable(&str, pSql)) != TSDB_CODE_SUCCESS) {
@@ -1122,12 +1112,12 @@ int tsParseInsertSql(SSqlObj *pSql) {
      tscError("%p async insert parse error, code:%s", pSql, tstrerror(code));
      pCmd->curSql = NULL;
-      goto _error;
+      goto _clean;
    }
    if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
      code = tscInvalidSQLErrMsg(pCmd->payload, "insert data into super table is not supported", NULL);
-      goto _error;
+      goto _clean;
    }
    index = 0;
@@ -1136,7 +1126,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
    if (sToken.n == 0) {
      code = tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES or FILE required", sToken.z);
-      goto _error;
+      goto _clean;
    }
    STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
@@ -1148,32 +1138,32 @@ int tsParseInsertSql(SSqlObj *pSql) {
      tscSetAssignedColumnInfo(&spd, pSchema, tinfo.numOfColumns);
      if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
-        goto _error;
+        goto _clean;
      }
      /*
       * app here insert data in different vnodes, so we need to set the following
       * data in another submit procedure using async insert routines
       */
-      code = doParseInsertStatement(pSql, pCmd->pTableList, &str, &spd, &totalNum);
+      code = doParseInsertStatement(pCmd, &str, &spd, &totalNum);
      if (code != TSDB_CODE_SUCCESS) {
-        goto _error;
+        goto _clean;
      }
    } else if (sToken.type == TK_FILE) {
      if (validateDataSource(pCmd, DATA_FROM_DATA_FILE, sToken.z) != TSDB_CODE_SUCCESS) {
-        goto _error;
+        goto _clean;
      }
      index = 0;
      sToken = tStrGetToken(str, &index, false, 0, NULL);
      if (sToken.type != TK_STRING && sToken.type != TK_ID) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "file path is required following keyword FILE", sToken.z);
-        goto _error;
+        goto _clean;
      }
      str += index;
      if (sToken.n == 0) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "file path is required following keyword FILE", sToken.z);
-        goto _error;
+        goto _clean;
      }
      strncpy(pCmd->payload, sToken.z, sToken.n);
@@ -1183,7 +1173,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
      wordexp_t full_path;
      if (wordexp(pCmd->payload, &full_path, 0) != 0) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "invalid filename", sToken.z);
-        goto _error;
+        goto _clean;
      }
      tstrncpy(pCmd->payload, full_path.we_wordv[0], pCmd->allocSize);
@@ -1195,7 +1185,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
      SSchema *   pSchema = tscGetTableSchema(pTableMeta);
      if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
-        goto _error;
+        goto _clean;
      }
      SParsedDataColInfo spd = {0};
@@ -1230,7 +1220,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
            if (spd.hasVal[t] == true) {
              code = tscInvalidSQLErrMsg(pCmd->payload, "duplicated column name", sToken.z);
-              goto _error;
+              goto _clean;
            }
            spd.hasVal[t] = true;
@@ -1241,13 +1231,13 @@ int tsParseInsertSql(SSqlObj *pSql) {
        if (!findColumnIndex) {
          code = tscInvalidSQLErrMsg(pCmd->payload, "invalid column name", sToken.z);
-          goto _error;
+          goto _clean;
        }
      }
      if (spd.numOfAssignedCols == 0 || spd.numOfAssignedCols > tinfo.numOfColumns) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "column name expected", sToken.z);
-        goto _error;
+        goto _clean;
      }
      index = 0;
@@ -1256,16 +1246,16 @@ int tsParseInsertSql(SSqlObj *pSql) {
      if (sToken.type != TK_VALUES) {
        code = tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES is expected", sToken.z);
-        goto _error;
+        goto _clean;
      }
-      code = doParseInsertStatement(pSql, pCmd->pTableList, &str, &spd, &totalNum);
+      code = doParseInsertStatement(pCmd, &str, &spd, &totalNum);
      if (code != TSDB_CODE_SUCCESS) {
-        goto _error;
+        goto _clean;
      }
    } else {
      code = tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES or FILE are required", sToken.z);
-      goto _error;
+      goto _clean;
    }
  }
@@ -1274,25 +1264,18 @@ int tsParseInsertSql(SSqlObj *pSql) {
    goto _clean;
  }
-  if (taosArrayGetSize(pCmd->pDataBlocks) > 0) { // merge according to vgId
+  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) { // merge according to vgId
-    if ((code = tscMergeTableDataBlocks(pSql, pCmd->pDataBlocks)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscMergeTableDataBlocks(pSql)) != TSDB_CODE_SUCCESS) {
-      goto _error;
+      goto _clean;
    }
  }
  code = TSDB_CODE_SUCCESS;
  goto _clean;
-_error:
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
 _clean:
-  taosHashCleanup(pCmd->pTableList);
+  pCmd->curSql     = NULL;
-  pCmd->pTableList = NULL;
-  pCmd->curSql    = NULL;
  pCmd->parseFinished  = 1;
  return code;
 }
@@ -1309,7 +1292,6 @@ int tsInsertInitialCheck(SSqlObj *pSql) {
  pCmd->count = 0;
  pCmd->command = TSDB_SQL_INSERT;
-  pSql->res.numOfRows = 0;
  SQueryInfo *pQueryInfo = tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex);
@@ -1373,7 +1355,8 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
      pSql->parseRetry++;
      ret = tscToSQLCmd(pSql, &SQLInfo);
    }
-    SQLInfoDestroy(&SQLInfo);
+    SqlInfoDestroy(&SQLInfo);
  }
  /*
@@ -1399,7 +1382,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
    return tscInvalidSQLErrMsg(pCmd->payload, "too many rows in sql, total number of rows should be less than 32767", NULL);
  }
-  if ((code = tscMergeTableDataBlocks(pSql, pCmd->pDataBlocks)) != TSDB_CODE_SUCCESS) {
+  if ((code = tscMergeTableDataBlocks(pSql)) != TSDB_CODE_SUCCESS) {
    return code;
  }
@@ -1456,18 +1439,21 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
  int32_t count = 0;
  int32_t maxRows = 0;
-  tscDestroyBlockArrayList(pSql->cmd.pDataBlocks);
+  tfree(pCmd->pTableMetaList);
-  pCmd->pDataBlocks = taosArrayInit(1, POINTER_BYTES);
+  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  if (pCmd->pTableBlockHashList == NULL) {
+    pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+  }
  STableDataBlocks *pTableDataBlock = NULL;
-  int32_t ret = tscCreateDataBlock(TSDB_PAYLOAD_SIZE, tinfo.rowSize, sizeof(SSubmitBlk), pTableMetaInfo->name, pTableMeta, &pTableDataBlock);
+  int32_t ret = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE,
+                                        sizeof(SSubmitBlk), tinfo.rowSize, pTableMetaInfo->name, pTableMeta, &pTableDataBlock, NULL);
  if (ret != TSDB_CODE_SUCCESS) {
 //    return ret;
  }
-  taosArrayPush(pCmd->pDataBlocks, &pTableDataBlock);
  tscAllocateMemIfNeed(pTableDataBlock, tinfo.rowSize, &maxRows);
  char *tokenBuf = calloc(1, 4096);
  while ((readLen = tgetline(&line, &n, fp)) != -1) {
@@ -1529,8 +1515,6 @@ void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql) {
  SImportFileSupport *pSupporter = calloc(1, sizeof(SImportFileSupport));
  SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);
-  pNew->cmd.pDataBlocks = taosArrayInit(4, POINTER_BYTES);
  pCmd->count = 1;
  FILE *fp = fopen(pCmd->payload, "r");
@@ -1538,7 +1522,7 @@ void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql) {
    pSql->res.code = TAOS_SYSTEM_ERROR(errno);
    tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));
-    tfree(pSupporter)
+    tfree(pSupporter);
    tscQueueAsyncRes(pSql);
    return;

--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -800,9 +800,9 @@ static int insertStmtExecute(STscStmt* stmt) {
  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
  assert(pCmd->numOfClause == 1);
-  if (taosArrayGetSize(pCmd->pDataBlocks) > 0) {
+  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) {
    // merge according to vgid
-    int code = tscMergeTableDataBlocks(stmt->pSql, pCmd->pDataBlocks);
+    int code = tscMergeTableDataBlocks(stmt->pSql);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }

--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -262,6 +262,11 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
  SSqlStream *pStream = pObj->streamList;
  while (pStream) {
    tstrncpy(pSdesc->sql, pStream->pSql->sqlstr, sizeof(pSdesc->sql));
+    if (pStream->dstTable == NULL) {
+      pSdesc->dstTable[0] = 0;
+    } else {
+      tstrncpy(pSdesc->dstTable, pStream->dstTable, sizeof(pSdesc->dstTable));
+    }
    pSdesc->streamId = htonl(pStream->streamId);
    pSdesc->num = htobe64(pStream->num);

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -147,12 +147,18 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
  SSqlObj *pSql = tres;
  SSqlRes *pRes = &pSql->res;
-  if (code == 0) {
+  if (code == TSDB_CODE_SUCCESS) {
    SHeartBeatRsp *pRsp = (SHeartBeatRsp *)pRes->pRsp;
-    SRpcEpSet *    epSet = &pRsp->epSet;
+    SRpcEpSet     *epSet = &pRsp->epSet;
    if (epSet->numOfEps > 0) {
      tscEpSetHtons(epSet);
-      tscUpdateMgmtEpSet(pSql, epSet);
+      if (!tscEpSetIsEqual(&pSql->pTscObj->tscCorMgmtEpSet->epSet, epSet)) {
+        tscTrace("%p updating epset: numOfEps: %d, inUse: %d", pSql, epSet->numOfEps, epSet->inUse);
+        for (int8_t i = 0; i < epSet->numOfEps; i++) {
+          tscTrace("endpoint %d: fqdn=%s, port=%d", i, epSet->fqdn[i], epSet->port[i]);
+        }
+        tscUpdateMgmtEpSet(pSql, epSet);
+      }
    }
    pSql->pTscObj->connId = htonl(pRsp->connId);
@@ -161,11 +167,40 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
      tscKillConnection(pObj);
      return;
    } else {
-      if (pRsp->queryId) tscKillQuery(pObj, htonl(pRsp->queryId));
+      if (pRsp->queryId) {
-      if (pRsp->streamId) tscKillStream(pObj, htonl(pRsp->streamId));
+        tscKillQuery(pObj, htonl(pRsp->queryId));
+      }
+      if (pRsp->streamId) {
+        tscKillStream(pObj, htonl(pRsp->streamId));
+      }
    }
+    int32_t total  = htonl(pRsp->totalDnodes);
+    int32_t online = htonl(pRsp->onlineDnodes);
+    assert(online <= total);
+    if (online < total) {
+      tscError("HB:%p, total dnode:%d, online dnode:%d", pSql, total, online);
+      pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+    }
+    if (pRes->length == NULL) {
+      pRes->length = calloc(2,  sizeof(int32_t));
+    }
+    pRes->length[0] = total;
+    pRes->length[1] = online;
  } else {
    tscDebug("%" PRId64 " heartbeat failed, code:%s", pObj->hbrid, tstrerror(code));
+    if (pRes->length == NULL) {
+      pRes->length = calloc(2, sizeof(int32_t));
+    }
+    pRes->length[1] = 0;
+    if (pRes->length[0] == 0) {
+      pRes->length[0] = 1; // make sure that the value of the total node is greater than the online node
+    }
  }
  if (pObj->hbrid != 0) {
@@ -280,18 +315,20 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
  }
  int32_t cmd = pCmd->command;
-  if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_FETCH || cmd == TSDB_SQL_INSERT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
+  // 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.submitSchema = 1;
+  }
+  if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_FETCH || 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 ||
+       rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
-       rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE)) {
-    tscWarn("%p it shall renew table meta, code:%s, retry:%d", pSql, tstrerror(rpcMsg->code), ++pSql->retry);
+    pSql->retry++;
+    tscWarn("%p it shall renew table meta, code:%s, retry:%d", pSql, tstrerror(rpcMsg->code), pSql->retry);
-    // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
-    if (rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
-      pSql->cmd.submitSchema = 1;
-    }
    pSql->res.code = rpcMsg->code;  // keep the previous error code
    if (pSql->retry > pSql->maxRetry) {
@@ -451,10 +488,10 @@ int tscProcessSql(SSqlObj *pSql) {
 int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg *) pSql->cmd.payload;
-  pRetrieveMsg->qhandle = htobe64(pSql->res.qhandle);
  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
-  pRetrieveMsg->free = htons(pQueryInfo->type);
+  pRetrieveMsg->free    = htons(pQueryInfo->type);
+  pRetrieveMsg->qhandle = htobe64(pSql->res.qhandle);
  // todo valid the vgroupId at the client side
  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -681,7 +718,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  pQueryMsg->tagNameRelType = htons(pQueryInfo->tagCond.relType);
  pQueryMsg->numOfTags      = htonl(numOfTags);
  pQueryMsg->queryType      = htonl(pQueryInfo->type);
-  pQueryMsg->tableLimit     = htobe64(pQueryInfo->tableLimit);
+  pQueryMsg->vgroupLimit     = htobe64(pQueryInfo->vgroupLimit);
  size_t numOfOutput = tscSqlExprNumOfExprs(pQueryInfo);
  pQueryMsg->numOfOutput = htons((int16_t)numOfOutput);  // this is the stage one output column number
@@ -1234,12 +1271,12 @@ int32_t tscBuildKillMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
  SSqlCmd *pCmd = &(pSql->cmd);
+  int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg);
-  int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg);
  SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
  if (pCreateTableInfo->type == TSQL_CREATE_TABLE_FROM_STABLE) {
-    size += sizeof(STagData);
+    int32_t numOfTables = (int32_t)taosArrayGetSize(pInfo->pCreateTableInfo->childTableInfo);
+    size += numOfTables * (sizeof(SCreateTableMsg) + TSDB_MAX_TAGS_LEN);
  } else {
    size += sizeof(SSchema) * (pCmd->numOfCols + pCmd->count);
  }
@@ -1267,33 +1304,55 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
  }
  SCMCreateTableMsg *pCreateTableMsg = (SCMCreateTableMsg *)pCmd->payload;
-  strcpy(pCreateTableMsg->tableId, pTableMetaInfo->name);
-  // use dbinfo from table id without modifying current db info
+  SCreateTableMsg* pCreateMsg = (SCreateTableMsg*)((char*) pCreateTableMsg + sizeof(SCMCreateTableMsg));
-  tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateTableMsg->db);
+  char* pMsg = NULL;
-  SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
+  int8_t type = pInfo->pCreateTableInfo->type;
+  if (type == TSQL_CREATE_TABLE_FROM_STABLE) {  // create by using super table, tags value
+    SArray* list = pInfo->pCreateTableInfo->childTableInfo;
-  pCreateTableMsg->igExists = pCreateTable->existCheck ? 1 : 0;
+    int32_t numOfTables = (int32_t) taosArrayGetSize(list);
-  pCreateTableMsg->numOfColumns = htons(pCmd->numOfCols);
+    pCreateTableMsg->numOfTables = htonl(numOfTables);
-  pCreateTableMsg->numOfTags = htons(pCmd->count);
-  pCreateTableMsg->sqlLen = 0;
+    pMsg = (char*) pCreateMsg;
-  char *pMsg = (char *)pCreateTableMsg->schema;
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      SCreateTableMsg* pCreate = (SCreateTableMsg*) pMsg;
-  int8_t type = pInfo->pCreateTableInfo->type;
+      pCreate->numOfColumns = htons(pCmd->numOfCols);
-  if (type == TSQL_CREATE_TABLE_FROM_STABLE) {  // create by using super table, tags value
+      pCreate->numOfTags = htons(pCmd->count);
-    STagData* pTag = &pInfo->pCreateTableInfo->usingInfo.tagdata;
+      pMsg += sizeof(SCreateTableMsg);
-    *(int32_t*)pMsg = htonl(pTag->dataLen);
-    pMsg += sizeof(int32_t);
+      SCreatedTableInfo* p = taosArrayGet(list, i);
-    memcpy(pMsg, pTag->name, sizeof(pTag->name));
+      strcpy(pCreate->tableId, p->fullname);
-    pMsg += sizeof(pTag->name);
+      pCreate->igExists = (p->igExist)? 1 : 0;
-    memcpy(pMsg, pTag->data, pTag->dataLen);
-    pMsg += pTag->dataLen;
+      // use dbinfo from table id without modifying current db info
+      tscGetDBInfoFromTableFullName(p->fullname, pCreate->db);
+      pMsg = serializeTagData(&p->tagdata, pMsg);
+      int32_t len = (int32_t)(pMsg - (char*) pCreate);
+      pCreate->len = htonl(len);
+    }
  } else {  // create (super) table
-    pSchema = (SSchema *)pCreateTableMsg->schema;
+    pCreateTableMsg->numOfTables = htonl(1); // only one table will be created
+    strcpy(pCreateMsg->tableId, pTableMetaInfo->name);
+    // use dbinfo from table id without modifying current db info
+    tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateMsg->db);
+    SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
+    pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0;
+    pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
+    pCreateMsg->numOfTags = htons(pCmd->count);
+    pCreateMsg->sqlLen = 0;
+    pMsg = (char *)pCreateMsg->schema;
+    pSchema = (SSchema *)pCreateMsg->schema;
    for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
      TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
@@ -1310,7 +1369,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
      SQuerySQL *pQuerySql = pInfo->pCreateTableInfo->pSelect;
      strncpy(pMsg, pQuerySql->selectToken.z, pQuerySql->selectToken.n + 1);
-      pCreateTableMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
+      pCreateMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
      pMsg += pQuerySql->selectToken.n + 1;
    }
  }
@@ -1394,6 +1453,43 @@ int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
  return TSDB_CODE_SUCCESS;
 }
+//int tscBuildCancelQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+//  SCancelQueryMsg *pCancelMsg = (SCancelQueryMsg*) pSql->cmd.payload;
+//  pCancelMsg->qhandle = htobe64(pSql->res.qhandle);
+//
+//  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
+//  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+//
+//  if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+//    int32_t vgIndex = pTableMetaInfo->vgroupIndex;
+//    if (pTableMetaInfo->pVgroupTables == NULL) {
+//      SVgroupsInfo *pVgroupInfo = pTableMetaInfo->vgroupList;
+//      assert(pVgroupInfo->vgroups[vgIndex].vgId > 0 && vgIndex < pTableMetaInfo->vgroupList->numOfVgroups);
+//
+//      pCancelMsg->header.vgId = htonl(pVgroupInfo->vgroups[vgIndex].vgId);
+//      tscDebug("%p build cancel query msg from vgId:%d, vgIndex:%d", pSql, pVgroupInfo->vgroups[vgIndex].vgId, vgIndex);
+//    } else {
+//      int32_t numOfVgroups = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+//      assert(vgIndex >= 0 && vgIndex < numOfVgroups);
+//
+//      SVgroupTableInfo* pTableIdList = taosArrayGet(pTableMetaInfo->pVgroupTables, vgIndex);
+//
+//      pCancelMsg->header.vgId = htonl(pTableIdList->vgInfo.vgId);
+//      tscDebug("%p build cancel query msg from vgId:%d, vgIndex:%d", pSql, pTableIdList->vgInfo.vgId, vgIndex);
+//    }
+//  } else {
+//    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+//    pCancelMsg->header.vgId = htonl(pTableMeta->vgroupInfo.vgId);
+//    tscDebug("%p build cancel query msg from only one vgroup, vgId:%d", pSql, pTableMeta->vgroupInfo.vgId);
+//  }
+//
+//  pSql->cmd.payloadLen = sizeof(SCancelQueryMsg);
+//  pSql->cmd.msgType = TSDB_MSG_TYPE_CANCEL_QUERY;
+//
+//  pCancelMsg->header.contLen = htonl(sizeof(SCancelQueryMsg));
+//  return TSDB_CODE_SUCCESS;
+//}
 int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  SSqlCmd *pCmd = &pSql->cmd;
  pCmd->payloadLen = sizeof(SAlterDbMsg);
@@ -1550,13 +1646,8 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  char *pMsg = (char *)pInfoMsg + sizeof(STableInfoMsg);
-  if (pCmd->autoCreated && pCmd->pTagData != NULL) {
+  if (pCmd->autoCreated && pCmd->tagData.dataLen != 0) {
-    int len = htonl(pCmd->pTagData->dataLen);
+    pMsg = serializeTagData(&pCmd->tagData, pMsg);
-    if (len > 0) {
-      len += sizeof(pCmd->pTagData->name) + sizeof(pCmd->pTagData->dataLen);
-      memcpy(pInfoMsg->tags, pCmd->pTagData, len);
-      pMsg += len;
-    }
  }
  pCmd->payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
@@ -2056,6 +2147,10 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
  if (pConnect->epSet.numOfEps > 0) {
    tscEpSetHtons(&pConnect->epSet);
    tscUpdateMgmtEpSet(pSql, &pConnect->epSet);
+    for (int i = 0; i < pConnect->epSet.numOfEps; ++i) {
+      tscDebug("%p epSet.fqdn[%d]: %s, pObj:%p", pSql, i, pConnect->epSet.fqdn[i], pObj);
+    }
  } 
  strcpy(pObj->sversion, pConnect->serverVersion);
@@ -2102,10 +2197,7 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
   */
  tscDebug("%p force release table meta after drop table:%s", pSql, pTableMetaInfo->name);
  taosCacheRelease(tscMetaCache, (void **)&pTableMeta, true);
+  assert(pTableMetaInfo->pTableMeta == NULL);
-  if (pTableMetaInfo->pTableMeta) {
-    taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
-  }
  return 0;
 }
@@ -2213,7 +2305,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
 void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
-static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
  if (NULL == pNew) {
    tscError("%p malloc failed for new sqlobj to get table meta", pSql);
@@ -2240,15 +2332,13 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf
  tstrncpy(pNewMeterMetaInfo->name, pTableMetaInfo->name, sizeof(pNewMeterMetaInfo->name));
-  if (pSql->cmd.pTagData != NULL) {
+  if (pSql->cmd.autoCreated) {
-    int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
+    int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
-    pNew->cmd.pTagData = calloc(1, size);
+    if (code != TSDB_CODE_SUCCESS) {
-    if (pNew->cmd.pTagData == NULL) {
      tscError("%p malloc failed for new tag data to get table meta", pSql);
      tscFreeSqlObj(pNew);
      return TSDB_CODE_TSC_OUT_OF_MEMORY;
    }
-    memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
  }
  tscDebug("%p new pSqlObj:%p to get tableMeta, auto create:%d", pSql, pNew, pNew->cmd.autoCreated);
@@ -2283,10 +2373,10 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
    return TSDB_CODE_SUCCESS;
  }
-  return getTableMetaFromMgmt(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo);
 }
-int tscGetMeterMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
+int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
  pSql->cmd.autoCreated = createIfNotExists;
  return tscGetTableMeta(pSql, pTableMetaInfo);
 }
@@ -2310,7 +2400,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
  }
  taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
-  return getTableMetaFromMgmt(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo);
 }
 static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) {

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -900,9 +900,9 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  strtolower(pSql->sqlstr, sql);
  pCmd->curSql = NULL;
-  if (NULL != pCmd->pTableList) {
+  if (NULL != pCmd->pTableBlockHashList) {
-    taosHashCleanup(pCmd->pTableList);
+    taosHashCleanup(pCmd->pTableBlockHashList);
-    pCmd->pTableList = NULL;
+    pCmd->pTableBlockHashList = NULL;
  }
  pSql->fp = asyncCallback;

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -535,6 +535,10 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
           pStream, pTableMetaInfo->name, pStream->interval.interval, pStream->interval.sliding, starttime, pSql->sqlstr);
 }
+void tscSetStreamDestTable(SSqlStream* pStream, const char* dstTable) {
+  pStream->dstTable = dstTable;
+}
 TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
                              int64_t stime, void *param, void (*callback)(void *)) {
  STscObj *pObj = (STscObj *)taos;

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -384,7 +384,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
    }
    SQueryInfo *pSubQueryInfo = tscGetQueryInfoDetail(&pPrevSub->cmd, 0);
-    STSBuf *pTSBuf = pSubQueryInfo->tsBuf;
+    STSBuf     *pTsBuf = pSubQueryInfo->tsBuf;
    pSubQueryInfo->tsBuf = NULL;
    // free result for async object will also free sqlObj
@@ -402,7 +402,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
    pSql->pSubs[i] = pNew;
    SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0);
-    pQueryInfo->tsBuf = pTSBuf;  // transfer the ownership of timestamp comp-z data to the new created object
+    pQueryInfo->tsBuf = pTsBuf;  // transfer the ownership of timestamp comp-z data to the new created object
    // set the second stage sub query for join process
    TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE);
@@ -1648,7 +1648,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
  pRes->qhandle = 0x1;  // hack the qhandle check
-  const uint32_t nBufferSize = (1u << 16);  // 64KB
+  const uint32_t nBufferSize = (1u << 16u);  // 64KB
  SQueryInfo     *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -2149,6 +2149,38 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
  }
 }
+static bool needRetryInsert(SSqlObj* pParentObj, int32_t numOfSub) {
+  if (pParentObj->retry > pParentObj->maxRetry) {
+    tscError("%p max retry reached, abort the retry effort", pParentObj);
+    return false;
+  }
+  for (int32_t i = 0; i < numOfSub; ++i) {
+    int32_t code = pParentObj->pSubs[i]->res.code;
+    if (code == TSDB_CODE_SUCCESS) {
+      continue;
+    }
+    if (code != TSDB_CODE_TDB_TABLE_RECONFIGURE && code != TSDB_CODE_TDB_INVALID_TABLE_ID &&
+        code != TSDB_CODE_VND_INVALID_VGROUP_ID && code != TSDB_CODE_RPC_NETWORK_UNAVAIL &&
+        code != TSDB_CODE_APP_NOT_READY) {
+      pParentObj->res.code = code;
+      return false;
+    }
+  }
+  return true;
+}
+static void doFreeInsertSupporter(SSqlObj* pSqlObj) {
+  assert(pSqlObj != NULL && pSqlObj->subState.numOfSub > 0);
+  for(int32_t i = 0; i < pSqlObj->subState.numOfSub; ++i) {
+    SSqlObj* pSql = pSqlObj->pSubs[i];
+    tfree(pSql->param);
+  }
+}
 static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows) {
  SInsertSupporter *pSupporter = (SInsertSupporter *)param;
  SSqlObj* pParentObj = pSupporter->pSql;
@@ -2163,23 +2195,81 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
    assert(pSql != NULL && pSql->res.code == numOfRows);
    pParentObj->res.code = pSql->res.code;
-  }
-  tfree(pSupporter);
+    // set the flag in the parent sqlObj
+    if (pSql->cmd.submitSchema) {
+      pParentObj->cmd.submitSchema = 1;
+    }
+  }
  if (atomic_sub_fetch_32(&pParentObj->subState.numOfRemain, 1) > 0) {
    return;
  }
-  tscDebug("%p Async insertion completed, total inserted:%d", pParentObj, pParentObj->res.numOfRows);
  // restore user defined fp
  pParentObj->fp = pParentObj->fetchFp;
+  int32_t numOfSub = pParentObj->subState.numOfSub;
+  doFreeInsertSupporter(pParentObj);
+  if (pParentObj->res.code == TSDB_CODE_SUCCESS) {
+    tscDebug("%p Async insertion completed, total inserted:%d", pParentObj, pParentObj->res.numOfRows);
-  // todo remove this parameter in async callback function definition.
+    // todo remove this parameter in async callback function definition.
-  // all data has been sent to vnode, call user function
+    // all data has been sent to vnode, call user function
-  int32_t v = (pParentObj->res.code != TSDB_CODE_SUCCESS) ? pParentObj->res.code : (int32_t)pParentObj->res.numOfRows;
+    int32_t v = (pParentObj->res.code != TSDB_CODE_SUCCESS) ? pParentObj->res.code : (int32_t)pParentObj->res.numOfRows;
-  (*pParentObj->fp)(pParentObj->param, pParentObj, v);
+    (*pParentObj->fp)(pParentObj->param, pParentObj, v);
+  } else {
+    if (!needRetryInsert(pParentObj, numOfSub)) {
+      tscQueueAsyncRes(pParentObj);
+      return;
+    }
+    int32_t numOfFailed = 0;
+    for(int32_t i = 0; i < numOfSub; ++i) {
+      SSqlObj* pSql = pParentObj->pSubs[i];
+      if (pSql->res.code != TSDB_CODE_SUCCESS) {
+        numOfFailed += 1;
+        // clean up tableMeta in cache
+        tscFreeQueryInfo(&pSql->cmd, true);
+        SQueryInfo* pQueryInfo = tscGetQueryInfoDetailSafely(&pSql->cmd, 0);
+        STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentObj->cmd, pSql->cmd.clauseIndex, 0);
+        tscAddTableMetaInfo(pQueryInfo, pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
+        tscDebug("%p, failed sub:%d, %p", pParentObj, i, pSql);
+      }
+    }
+    tscError("%p Async insertion completed, total inserted:%d rows, numOfFailed:%d, numOfTotal:%d", pParentObj,
+             pParentObj->res.numOfRows, numOfFailed, numOfSub);
+    tscDebug("%p cleanup %d tableMeta in cache", pParentObj, pParentObj->cmd.numOfTables);
+    for(int32_t i = 0; i < pParentObj->cmd.numOfTables; ++i) {
+      taosCacheRelease(tscMetaCache, (void**)&(pParentObj->cmd.pTableMetaList[i]), true);
+    }
+    pParentObj->cmd.parseFinished = false;
+    pParentObj->subState.numOfRemain = numOfFailed;
+    tscResetSqlCmdObj(&pParentObj->cmd, false);
+    // in case of insert, redo parsing the sql string and build new submit data block for two reasons:
+    // 1. the table Id(tid & uid) may have been update, the submit block needs to be updated accordingly.
+    // 2. vnode may need the schema information along with submit block to update its local table schema.
+    tscDebug("%p re-parse sql to generate submit data, retry:%d", pParentObj, pParentObj->retry);
+    pParentObj->retry++;
+    int32_t code = tsParseSql(pParentObj, true);
+    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return;
+    if (code != TSDB_CODE_SUCCESS) {
+      pParentObj->res.code = code;
+      tscQueueAsyncRes(pParentObj);
+      return;
+    }
+    tscDoQuery(pParentObj);
+  }
 }
 /**
@@ -2187,20 +2277,16 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
 * @param pSql
 * @return
 */
-int32_t tscHandleInsertRetry(SSqlObj* pSql) {
+int32_t tscHandleInsertRetry(SSqlObj* pParent, SSqlObj* pSql) {
  assert(pSql != NULL && pSql->param != NULL);
-  SSqlCmd* pCmd = &pSql->cmd;
  SSqlRes* pRes = &pSql->res;
  SInsertSupporter* pSupporter = (SInsertSupporter*) pSql->param;
  assert(pSupporter->index < pSupporter->pSql->subState.numOfSub);
-  STableDataBlocks* pTableDataBlock = taosArrayGetP(pCmd->pDataBlocks, pSupporter->index);
+  STableDataBlocks* pTableDataBlock = taosArrayGetP(pParent->cmd.pDataBlocks, pSupporter->index);
  int32_t code = tscCopyDataBlockToPayload(pSql, pTableDataBlock);
-  // free the data block created from insert sql string
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
  if ((pRes->code = code)!= TSDB_CODE_SUCCESS) {
    tscQueueAsyncRes(pSql);
    return code;  // here the pSql may have been released already.
@@ -2213,6 +2299,24 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
+  // it is the failure retry insert
+  if (pSql->pSubs != NULL) {
+    for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
+      SSqlObj* pSub = pSql->pSubs[i];
+      SInsertSupporter* pSup = calloc(1, sizeof(SInsertSupporter));
+      pSup->index = i;
+      pSup->pSql = pSql;
+      pSub->param = pSup;
+      tscDebug("%p sub:%p launch sub insert, orderOfSub:%d", pSql, pSub, i);
+      if (pSub->res.code != TSDB_CODE_SUCCESS) {
+        tscHandleInsertRetry(pSql, pSub);
+      }
+    }
+    return TSDB_CODE_SUCCESS;
+  }
  pSql->subState.numOfSub = (uint16_t)taosArrayGetSize(pCmd->pDataBlocks);
  assert(pSql->subState.numOfSub > 0);
@@ -2399,12 +2503,12 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
    tscRestoreSQLFuncForSTableQuery(pQueryInfo);
  }
-  while (1) {
+  assert (pRes->row >= pRes->numOfRows);
-    assert (pRes->row >= pRes->numOfRows);
+  doBuildResFromSubqueries(pSql);
+  if (pRes->code == TSDB_CODE_SUCCESS) {
-    doBuildResFromSubqueries(pSql);
+    (*pSql->fp)(pSql->param, pSql, pRes->numOfRows);
-    tsem_post(&pSql->rspSem);
+  } else {
-    return;
+    tscQueueAsyncRes(pSql);
  }
 }

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -333,13 +333,15 @@ void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
        if (isNull(p, TSDB_DATA_TYPE_NCHAR)) {
          memcpy(dst, p, varDataTLen(p));
-        } else {
+        } else if (varDataLen(p) > 0) {
          int32_t length = taosUcs4ToMbs(varDataVal(p), varDataLen(p), varDataVal(dst));
          varDataSetLen(dst, length);
          if (length == 0) {
            tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, (char*)p);
          }
+        } else {
+          varDataSetLen(dst, 0);
        }
        p += pInfo->field.bytes;
@@ -377,7 +379,7 @@ static void tscDestroyResPointerInfo(SSqlRes* pRes) {
  pRes->data = NULL;  // pRes->data points to the buffer of pRsp, no need to free
 }
-static void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeFromCache) {
+void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeFromCache) {
  if (pCmd == NULL || pCmd->numOfClause == 0) {
    return;
  }
@@ -403,12 +405,18 @@ void tscResetSqlCmdObj(SSqlCmd* pCmd, bool removeFromCache) {
  pCmd->msgType   = 0;
  pCmd->parseFinished = 0;
  pCmd->autoCreated = 0;
-  taosHashCleanup(pCmd->pTableList);
-  pCmd->pTableList = NULL;
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  for(int32_t i = 0; i < pCmd->numOfTables; ++i) {
+    if (pCmd->pTableMetaList && pCmd->pTableMetaList[i]) {
+      taosCacheRelease(tscMetaCache, (void**)&(pCmd->pTableMetaList[i]), false);
+    }
+  }
+  pCmd->numOfTables = 0;
+  tfree(pCmd->pTableMetaList);
+  pCmd->pTableBlockHashList = tscDestroyBlockHashTable(pCmd->pTableBlockHashList);
+  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
  tscFreeQueryInfo(pCmd, removeFromCache);
 }
@@ -510,7 +518,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
  tscFreeSqlResult(pSql);
  tscResetSqlCmdObj(pCmd, false);
-  tfree(pCmd->pTagData);
+  tfree(pCmd->tagData.data);
+  pCmd->tagData.dataLen = 0;
  memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
  tfree(pCmd->payload);
@@ -575,6 +584,21 @@ void*  tscDestroyBlockArrayList(SArray* pDataBlockList) {
  return NULL;
 }
+void* tscDestroyBlockHashTable(SHashObj* pBlockHashTable) {
+  if (pBlockHashTable == NULL) {
+    return NULL;
+  }
+  STableDataBlocks** p = taosHashIterate(pBlockHashTable, NULL);
+  while(p) {
+    tscDestroyDataBlock(*p);
+    p = taosHashIterate(pBlockHashTable, p);
+  }
+  taosHashCleanup(pBlockHashTable);
+  return NULL;
+}
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
  SSqlCmd* pCmd = &pSql->cmd;
  assert(pDataBlock->pTableMeta != NULL);
@@ -671,9 +695,8 @@ int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOff
  return TSDB_CODE_SUCCESS;
 }
-int32_t tscGetDataBlockFromList(void* pHashList, SArray* pDataBlockList, int64_t id, int32_t size,
+int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
-                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
+                                STableDataBlocks** dataBlocks, SArray* pBlockList) {
-                                STableDataBlocks** dataBlocks) {
  *dataBlocks = NULL;
  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pHashList, (const char*)&id, sizeof(id));
@@ -688,7 +711,9 @@ int32_t tscGetDataBlockFromList(void* pHashList, SArray* pDataBlockList, int64_t
    }
    taosHashPut(pHashList, (const char*)&id, sizeof(int64_t), (char*)dataBlocks, POINTER_BYTES);
-    taosArrayPush(pDataBlockList, dataBlocks);
+    if (pBlockList) {
+      taosArrayPush(pBlockList, dataBlocks);
+    }
  }
  return TSDB_CODE_SUCCESS;
@@ -769,22 +794,37 @@ static int32_t getRowExpandSize(STableMeta* pTableMeta) {
  return result;
 }
-int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
+static void extractTableMeta(SSqlCmd* pCmd) {
+  pCmd->numOfTables = (int32_t) taosHashGetSize(pCmd->pTableBlockHashList);
+  pCmd->pTableMetaList = calloc(pCmd->numOfTables, POINTER_BYTES);
+  STableDataBlocks **p1 = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  int32_t i = 0;
+  while(p1) {
+    STableDataBlocks* pBlocks = *p1;
+    pCmd->pTableMetaList[i++] = taosCacheTransfer(tscMetaCache, (void**) &pBlocks->pTableMeta);
+    p1 = taosHashIterate(pCmd->pTableBlockHashList, p1);
+  }
+  pCmd->pTableBlockHashList = tscDestroyBlockHashTable(pCmd->pTableBlockHashList);
+}
+int32_t tscMergeTableDataBlocks(SSqlObj* pSql) {
  SSqlCmd* pCmd = &pSql->cmd;
  void* pVnodeDataBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
  SArray* pVnodeDataBlockList = taosArrayInit(8, POINTER_BYTES);
-  size_t total = taosArrayGetSize(pTableDataBlockList);
+  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
-  for (int32_t i = 0; i < total; ++i) {
+  STableDataBlocks* pOneTableBlock = *p;
+  while(pOneTableBlock) {
    // the maximum expanded size in byte when a row-wise data is converted to SDataRow format
-    STableDataBlocks* pOneTableBlock = taosArrayGetP(pTableDataBlockList, i);
    int32_t expandSize = getRowExpandSize(pOneTableBlock->pTableMeta);
    STableDataBlocks* dataBuf = NULL;
-    int32_t ret =
+    int32_t ret = tscGetDataBlockFromList(pVnodeDataBlockHashList, pOneTableBlock->vgId, TSDB_PAYLOAD_SIZE,
-        tscGetDataBlockFromList(pVnodeDataBlockHashList, pVnodeDataBlockList, pOneTableBlock->vgId, TSDB_PAYLOAD_SIZE,
+                                tsInsertHeadSize, 0, pOneTableBlock->tableId, pOneTableBlock->pTableMeta, &dataBuf, pVnodeDataBlockList);
-                                tsInsertHeadSize, 0, pOneTableBlock->tableId, pOneTableBlock->pTableMeta, &dataBuf);
    if (ret != TSDB_CODE_SUCCESS) {
      tscError("%p failed to prepare the data block buffer for merging table data, code:%d", pSql, ret);
      taosHashCleanup(pVnodeDataBlockHashList);
@@ -839,14 +879,19 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
    // the length does not include the SSubmitBlk structure
    pBlocks->dataLen = htonl(finalLen);
    dataBuf->numOfTables += 1;
+    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    if (p == NULL) {
+      break;
+    }
+    pOneTableBlock = *p;
  }
-  tscDestroyBlockArrayList(pTableDataBlockList);
+  extractTableMeta(pCmd);
  // free the table data blocks;
  pCmd->pDataBlocks = pVnodeDataBlockList;
-//  tscFreeUnusedDataBlocks(pCmd->pDataBlocks);
  taosHashCleanup(pVnodeDataBlockHashList);
  return TSDB_CODE_SUCCESS;
@@ -1893,15 +1938,11 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
  pCmd->parseFinished = 1;
  pCmd->autoCreated = pSql->cmd.autoCreated;
-  if (pSql->cmd.pTagData != NULL) {
+  int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
-    int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
+  if (code != TSDB_CODE_SUCCESS) {
-    pNew->cmd.pTagData = calloc(1, size);
+    tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
-    if (pNew->cmd.pTagData == NULL) {
+    free(pNew);
-      tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
+    return NULL;
-      free(pNew);
-      return NULL;
-    }
-    memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
  }
  if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
@@ -2006,7 +2047,11 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
  pnCmd->numOfClause = 0;
  pnCmd->clauseIndex = 0;
  pnCmd->pDataBlocks = NULL;
+  pnCmd->numOfTables = 0;
  pnCmd->parseFinished = 1;
+  pnCmd->pTableMetaList = NULL;
+  pnCmd->pTableBlockHashList = NULL;
  if (tscAddSubqueryInfo(pnCmd) != TSDB_CODE_SUCCESS) {
    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -2023,6 +2068,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
  pNewQueryInfo->limit  = pQueryInfo->limit;
  pNewQueryInfo->slimit = pQueryInfo->slimit;
  pNewQueryInfo->order  = pQueryInfo->order;
+  pNewQueryInfo->vgroupLimit = pQueryInfo->vgroupLimit;
  pNewQueryInfo->tsBuf  = NULL;
  pNewQueryInfo->fillType = pQueryInfo->fillType;
  pNewQueryInfo->fillVal  = NULL;
@@ -2531,6 +2577,9 @@ void* tscVgroupInfoClear(SVgroupsInfo *vgroupList) {
    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);
@@ -2543,6 +2592,41 @@ void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src) {
  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);
+  pMsg += sizeof(n);
+  memcpy(pMsg, pTagData->name, n);
+  pMsg += n;
+  *(int32_t*)pMsg = htonl(pTagData->dataLen);
+  pMsg += sizeof(int32_t);
+  memcpy(pMsg, pTagData->data, pTagData->dataLen);
+  pMsg += pTagData->dataLen;
+  return pMsg;
+}
+int32_t copyTagData(STagData* dst, const STagData* src) {
+  dst->dataLen = src->dataLen;
+  tstrncpy(dst->name, src->name, tListLen(dst->name));
+  if (dst->dataLen > 0) {
+    dst->data = malloc(dst->dataLen);
+    if (dst->data == NULL) {
+      return -1;
+    }
+    memcpy(dst->data, src->data, dst->dataLen);
+  }
+  return 0;
+}
\ No newline at end of file
--- a/src/common/inc/tcmdtype.h
+++ b/src/common/inc/tcmdtype.h
@@ -36,7 +36,7 @@ enum {
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_FETCH, "fetch" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_INSERT, "insert" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_UPDATE_TAGS_VAL, "update-tag-val" )
  // the SQL below is for mgmt node
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MGMT, "mgmt" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DB, "create-db" )

--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -46,7 +46,7 @@ extern int32_t  tsShellActivityTimer;
 extern uint32_t tsMaxTmrCtrl;
 extern float    tsNumOfThreadsPerCore;
 extern int32_t  tsNumOfCommitThreads;
-extern float    tsRatioOfQueryThreads;  // todo remove it
+extern float    tsRatioOfQueryCores;
 extern int8_t   tsDaylight;
 extern char     tsTimezone[];
 extern char     tsLocale[];
@@ -57,7 +57,9 @@ extern char     tsTempDir[];
 //query buffer management
 extern int32_t  tsQueryBufferSize;      // maximum allowed usage buffer for each data node during query processing
-extern int32_t  tsHalfCoresForQuery;         // only 50% will be used in query processing
+extern int32_t  tsRetrieveBlockingModel;// retrieve threads will be blocked
+extern int32_t  tsKeepOriginalColumnName;
 // client
 extern int32_t tsTableMetaKeepTimer;
@@ -132,7 +134,7 @@ extern int32_t tsEnableStream;
 // internal
 extern int32_t tsPrintAuth;
-extern int32_t tscEmbedded;
+extern uint32_t tscEmbedded;
 extern char    configDir[];
 extern char    tsVnodeDir[];
 extern char    tsDnodeDir[];
@@ -174,7 +176,7 @@ extern int32_t tsLogKeepDays;
 extern int32_t dDebugFlag;
 extern int32_t vDebugFlag;
 extern int32_t mDebugFlag;
-extern int32_t cDebugFlag;
+extern uint32_t cDebugFlag;
 extern int32_t jniDebugFlag;
 extern int32_t tmrDebugFlag;
 extern int32_t sdbDebugFlag;
@@ -184,7 +186,7 @@ extern int32_t monDebugFlag;
 extern int32_t uDebugFlag;
 extern int32_t rpcDebugFlag;
 extern int32_t odbcDebugFlag;
-extern int32_t qDebugFlag;
+extern uint32_t qDebugFlag;
 extern int32_t wDebugFlag;
 extern int32_t cqDebugFlag;
 extern int32_t debugFlag;

--- a/src/common/inc/tulog.h
+++ b/src/common/inc/tulog.h
@@ -23,7 +23,7 @@ extern "C" {
 #include "tlog.h"
 extern int32_t uDebugFlag;
-extern int32_t tscEmbedded;
+extern uint32_t tscEmbedded;
 #define uFatal(...) { if (uDebugFlag & DEBUG_FATAL) { taosPrintLog("UTL FATAL", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
 #define uError(...) { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("UTL ERROR ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -705,7 +705,7 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
          *((int32_t *)payload) = TSDB_DATA_FLOAT_NULL;
          return 0;
        } else {
-          double  value;
+          double  value = -1;
          int32_t ret;
          ret = convertToDouble(pVariant->pz, pVariant->nLen, &value);
          if ((errno == ERANGE && (float)value == -1) || (ret != 0)) {

--- a/grafanaplugin @ 32e2c97a
+++ b/grafanaplugin @ 32e2c97a
-Subproject commit ec77d9049a719dabfd1a7c1122a209e201861944
+Subproject commit 32e2c97a4cf7bedaa99f5d6dd8cb036e7f4470df
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
--- a/src/cq/test/cqtest.c
+++ b/src/cq/test/cqtest.c
@@ -70,7 +70,7 @@ int main(int argc, char *argv[]) {
  tdDestroyTSchemaBuilder(&schemaBuilder);
  for (int sid =1; sid<10; ++sid) {
-    cqCreate(pCq, sid, sid, "select avg(speed) from demo.t1 sliding(1s) interval(5s)", pSchema);
+    cqCreate(pCq, sid, sid, NULL, "select avg(speed) from demo.t1 sliding(1s) interval(5s)", pSchema);
  }
  tdFreeSchema(pSchema);

--- a/src/dnode/inc/dnodeInt.h
+++ b/src/dnode/inc/dnodeInt.h
@@ -36,6 +36,14 @@ extern int32_t dDebugFlag;
 #define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
 #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
+typedef enum {
+  TSDB_RUN_STATUS_INITIALIZE,
+  TSDB_RUN_STATUS_RUNING,
+  TSDB_RUN_STATUS_STOPPED
+} SRunStatus;
+SRunStatus dnodeGetRunStatus();
 #ifdef __cplusplus
 }
 #endif

--- a/src/dnode/inc/dnodeModule.h
+++ b/src/dnode/inc/dnodeModule.h
--- a/src/dnode/inc/dnodeVRead.h
+++ b/src/dnode/inc/dnodeVRead.h
--- a/src/dnode/inc/dnodeVnodes.h
+++ b/src/dnode/inc/dnodeVnodes.h
--- a/src/dnode/src/dnodeEps.c
+++ b/src/dnode/src/dnodeEps.c
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
--- a/src/dnode/src/dnodeModule.c
+++ b/src/dnode/src/dnodeModule.c
--- a/src/dnode/src/dnodePeer.c
+++ b/src/dnode/src/dnodePeer.c
--- a/src/dnode/src/dnodeShell.c
+++ b/src/dnode/src/dnodeShell.c
--- a/src/dnode/src/dnodeStep.c
+++ b/src/dnode/src/dnodeStep.c
--- a/src/dnode/src/dnodeSystem.c
+++ b/src/dnode/src/dnodeSystem.c
--- a/src/dnode/src/dnodeVMgmt.c
+++ b/src/dnode/src/dnodeVMgmt.c
--- a/src/dnode/src/dnodeVRead.c
+++ b/src/dnode/src/dnodeVRead.c
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
--- a/src/inc/dnode.h
+++ b/src/inc/dnode.h
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
--- a/src/inc/tcq.h
+++ b/src/inc/tcq.h
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
--- a/src/inc/tsync.h
+++ b/src/inc/tsync.h
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
--- 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/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/mnode/inc/mnodeMnode.h
+++ b/src/mnode/inc/mnodeMnode.h
--- a/src/mnode/inc/mnodeSdb.h
+++ b/src/mnode/inc/mnodeSdb.h
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
--- a/src/mnode/src/mnodeMain.c
+++ b/src/mnode/src/mnodeMain.c
--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
--- a/src/mnode/src/mnodePeer.c
+++ b/src/mnode/src/mnodePeer.c
--- a/src/mnode/src/mnodeProfile.c
+++ b/src/mnode/src/mnodeProfile.c
--- a/src/mnode/src/mnodeRead.c
+++ b/src/mnode/src/mnodeRead.c
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
--- a/src/mnode/src/mnodeWrite.c
+++ b/src/mnode/src/mnodeWrite.c
--- a/src/os/inc/osMemory.h
+++ b/src/os/inc/osMemory.h
--- a/src/os/inc/osString.h
+++ b/src/os/inc/osString.h
--- 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/qUtil.h
+++ b/src/query/inc/qUtil.h
--- a/src/query/inc/queryLog.h
+++ b/src/query/inc/queryLog.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/inc/tsqlfunction.h
+++ b/src/query/inc/tsqlfunction.h
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qFilterfunc.c
+++ b/src/query/src/qFilterfunc.c
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/rpc/inc/rpcLog.h
+++ b/src/rpc/inc/rpcLog.h
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
--- a/src/rpc/src/rpcTcp.c
+++ b/src/rpc/src/rpcTcp.c
--- a/src/rpc/test/rclient.c
+++ b/src/rpc/test/rclient.c
--- a/src/sync/CMakeLists.txt
+++ b/src/sync/CMakeLists.txt
--- a/src/sync/inc/syncInt.h
+++ b/src/sync/inc/syncInt.h
--- a/src/sync/inc/syncMsg.h
+++ b/src/sync/inc/syncMsg.h
--- a/src/sync/inc/taosTcpPool.h
+++ b/src/sync/inc/taosTcpPool.h
--- a/src/sync/src/tarbitrator.c
+++ b/src/sync/src/tarbitrator.c
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
--- a/src/sync/src/syncMsg.c
+++ b/src/sync/src/syncMsg.c
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
--- a/src/sync/src/syncRetrieve.c
+++ b/src/sync/src/syncRetrieve.c
--- a/src/sync/src/taosTcpPool.c
+++ b/src/sync/src/taosTcpPool.c
--- a/src/sync/test/syncServer.c
+++ b/src/sync/test/syncServer.c
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
--- a/src/util/inc/tconfig.h
+++ b/src/util/inc/tconfig.h
--- a/src/util/inc/tstoken.h
+++ b/src/util/inc/tstoken.h
--- a/src/util/inc/tworker.h
+++ b/src/util/inc/tworker.h
--- a/src/util/src/tconfig.c
+++ b/src/util/src/tconfig.c
--- a/src/util/src/tqueue.c
+++ b/src/util/src/tqueue.c
--- a/src/util/src/ttimer.c
+++ b/src/util/src/ttimer.c
--- a/src/util/src/tworker.c
+++ b/src/util/src/tworker.c
--- a/src/vnode/inc/vnodeInt.h
+++ b/src/vnode/inc/vnodeInt.h
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/src/wal/inc/walInt.h
+++ b/src/wal/inc/walInt.h
--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
--- a/src/wal/test/waltest.c
+++ b/src/wal/test/waltest.c
--- a/tests/Jenkinsfile
+++ b/tests/Jenkinsfile
--- a/tests/examples/JDBC/taosdemo/.gitignore
+++ b/tests/examples/JDBC/taosdemo/.gitignore
--- a/tests/examples/JDBC/taosdemo/.mvn/wrapper/MavenWrapperDownloader.java
+++ b/tests/examples/JDBC/taosdemo/.mvn/wrapper/MavenWrapperDownloader.java
--- a/tests/examples/JDBC/taosdemo/.mvn/wrapper/maven-wrapper.jar
+++ b/tests/examples/JDBC/taosdemo/.mvn/wrapper/maven-wrapper.jar
--- a/tests/examples/JDBC/taosdemo/.mvn/wrapper/maven-wrapper.properties
+++ b/tests/examples/JDBC/taosdemo/.mvn/wrapper/maven-wrapper.properties
--- a/tests/examples/JDBC/taosdemo/mvnw
+++ b/tests/examples/JDBC/taosdemo/mvnw
--- a/tests/examples/JDBC/taosdemo/mvnw.cmd
+++ b/tests/examples/JDBC/taosdemo/mvnw.cmd
--- a/tests/examples/JDBC/taosdemo/pom.xml
+++ b/tests/examples/JDBC/taosdemo/pom.xml
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosdemoApplication.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosdemoApplication.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/components/TaosDemoCommandLineRunner.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/components/TaosDemoCommandLineRunner.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/DatabaseController.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/DatabaseController.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/InsertController.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/InsertController.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SubTableController.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SubTableController.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SuperTableController.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SuperTableController.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/TableController.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/TableController.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldMeta.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldMeta.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldValue.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldValue.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/RowValue.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/RowValue.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableMeta.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableMeta.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableValue.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableValue.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SuperTableMeta.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SuperTableMeta.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableMeta.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableMeta.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableValue.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableValue.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagMeta.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagMeta.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagValue.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagValue.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.xml
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.xml
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.xml
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.xml
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.xml
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.xml
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.xml
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.xml
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/AbstractService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/AbstractService.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/DatabaseService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/DatabaseService.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SuperTableService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SuperTableService.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/TableService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/TableService.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/FieldValueGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/FieldValueGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableMetaGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableMetaGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableValueGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableValueGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SuperTableMetaGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SuperTableMetaGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/TagValueGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/TagValueGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/DataGenerator.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/DataGenerator.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/JdbcTaosdemoConfig.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/JdbcTaosdemoConfig.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TaosConstants.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TaosConstants.java
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TimeStampUtil.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TimeStampUtil.java
--- a/tests/examples/JDBC/taosdemo/src/main/resources/application.properties
+++ b/tests/examples/JDBC/taosdemo/src/main/resources/application.properties
--- a/tests/examples/JDBC/taosdemo/src/main/resources/log4j.properties
+++ b/tests/examples/JDBC/taosdemo/src/main/resources/log4j.properties
--- a/tests/examples/JDBC/taosdemo/src/main/resources/templates/index.html
+++ b/tests/examples/JDBC/taosdemo/src/main/resources/templates/index.html
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/TaosdemoApplicationTests.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/TaosdemoApplicationTests.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/DatabaseMapperTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/DatabaseMapperTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SubTableMapperTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SubTableMapperTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SuperTableMapperTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SuperTableMapperTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/TableMapperTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/TableMapperTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SubTableServiceTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SubTableServiceTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/TableServiceTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/TableServiceTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/FieldValueGeneratorTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/FieldValueGeneratorTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SubTableMetaGeneratorTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SubTableMetaGeneratorTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SuperTableMetaGeneratorImplTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SuperTableMetaGeneratorImplTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/TagValueGeneratorTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/TagValueGeneratorTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/DataGeneratorTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/DataGeneratorTest.java
--- a/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/TimeStampUtilTest.java
+++ b/tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/TimeStampUtilTest.java
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
--- a/tests/examples/lua/OpenResty/conf/nginx.conf
+++ b/tests/examples/lua/OpenResty/conf/nginx.conf
--- a/tests/examples/lua/OpenResty/logs/.gitignore
+++ b/tests/examples/lua/OpenResty/logs/.gitignore
--- a/tests/examples/lua/OpenResty/rest/test.lua
+++ b/tests/examples/lua/OpenResty/rest/test.lua
--- a/tests/examples/lua/OpenResty/so/luaconnector51.so
+++ b/tests/examples/lua/OpenResty/so/luaconnector51.so
--- a/tests/examples/lua/README.md
+++ b/tests/examples/lua/README.md
--- a/tests/examples/lua/lua51/build.sh
+++ b/tests/examples/lua/lua51/build.sh
--- a/tests/examples/lua/lua51/lauxlib.h
+++ b/tests/examples/lua/lua51/lauxlib.h
--- a/tests/examples/lua/lua51/lua.h
+++ b/tests/examples/lua/lua51/lua.h
--- a/tests/examples/lua/lua51/lua_connector51.c
+++ b/tests/examples/lua/lua51/lua_connector51.c
--- a/tests/examples/lua/lua51/luaconf.h
+++ b/tests/examples/lua/lua51/luaconf.h
--- a/tests/examples/lua/lua51/luajit.h
+++ b/tests/examples/lua/lua51/luajit.h
--- a/tests/examples/lua/lua51/lualib.h
+++ b/tests/examples/lua/lua51/lualib.h
--- a/tests/examples/lua/lua_connector.c
+++ b/tests/examples/lua/lua_connector.c
--- a/tests/examples/lua/test.lua
+++ b/tests/examples/lua/test.lua
--- a/tests/pytest/concurrent_inquiry.py
+++ b/tests/pytest/concurrent_inquiry.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/functions/function_twa_test2.py
+++ b/tests/pytest/functions/function_twa_test2.py
--- a/tests/pytest/handle_crash_gen_val_log.sh
+++ b/tests/pytest/handle_crash_gen_val_log.sh
--- a/tests/pytest/pytest_1.sh
+++ b/tests/pytest/pytest_1.sh
--- a/tests/pytest/query/bug2118.py
+++ b/tests/pytest/query/bug2118.py
--- a/tests/pytest/query/floatCompare.py
+++ b/tests/pytest/query/floatCompare.py
--- a/tests/pytest/query/isNullTest.py
+++ b/tests/pytest/query/isNullTest.py
--- a/tests/pytest/query/queryError.py
+++ b/tests/pytest/query/queryError.py
--- a/tests/pytest/query/queryNullValueTest.py
+++ b/tests/pytest/query/queryNullValueTest.py
--- a/tests/pytest/query/queryWithTaosdKilled.py
+++ b/tests/pytest/query/queryWithTaosdKilled.py
--- a/tests/pytest/stream/stream2.py
+++ b/tests/pytest/stream/stream2.py
--- a/tests/pytest/table/createTableFromAnotherDb.py
+++ b/tests/pytest/table/createTableFromAnotherDb.py
--- a/tests/pytest/test.py
+++ b/tests/pytest/test.py
--- a/tests/pytest/update/append_commit_data.py
+++ b/tests/pytest/update/append_commit_data.py
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
--- a/tests/script/general/parser/fill.sim
+++ b/tests/script/general/parser/fill.sim
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
--- a/tests/script/general/parser/tags_filter.sim
+++ b/tests/script/general/parser/tags_filter.sim
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/script/jenkins/basic_3.txt
+++ b/tests/script/jenkins/basic_3.txt
--- a/tests/script/unique/arbitrator/insert_duplicationTs.sim
+++ b/tests/script/unique/arbitrator/insert_duplicationTs.sim
--- a/tests/script/unique/big/maxvnodes.sim
+++ b/tests/script/unique/big/maxvnodes.sim
--- a/tests/script/unique/db/replica_add12.sim
+++ b/tests/script/unique/db/replica_add12.sim
--- a/tests/script/unique/db/replica_add13.sim
+++ b/tests/script/unique/db/replica_add13.sim
--- a/tests/script/unique/db/replica_add23.sim
+++ b/tests/script/unique/db/replica_add23.sim
--- a/tests/script/unique/db/replica_part.sim
+++ b/tests/script/unique/db/replica_part.sim
--- a/tests/script/unique/db/replica_reduce21.sim
+++ b/tests/script/unique/db/replica_reduce21.sim
--- a/tests/script/unique/db/replica_reduce31.sim
+++ b/tests/script/unique/db/replica_reduce31.sim
--- a/tests/script/unique/db/replica_reduce32.sim
+++ b/tests/script/unique/db/replica_reduce32.sim
--- a/tests/test/c/CMakeLists.txt
+++ b/tests/test/c/CMakeLists.txt
--- a/tests/test/c/createTablePerformance.c
+++ b/tests/test/c/createTablePerformance.c