Merge pull request #4622 from taosdata/release/s109

Release/s109

Merge pull request #4622 from taosdata/release/s109
Release/s109
fef85ac0 · Shengliang Guan · GitHub · 11ff5820 · 950dd612 · fef85ac0
124 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 url: 'https://github.com/taosdata/TDengine.git'
 }
-// execute this before anything else, including requesting any time on an agent
+def abortPreviousBuilds() {
-if (currentBuild.rawBuild.getCauses().toString().contains('BranchIndexingCause')) {
+  def currentJobName = env.JOB_NAME
-  print "INFO: Build skipped due to trigger being Branch Indexing"
+  def currentBuildNumber = env.BUILD_NUMBER.toInteger()
-  currentBuild.result = 'ABORTED' // optional, gives a better hint to the user that it's been skipped, rather than the default which shows it's successful
+  def jobs = Jenkins.instance.getItemByFullName(currentJobName)
-  return
+  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 '''
@@ -20,6 +38,7 @@ def pre_test(){
                '''
    }
    sh '''
    cd ${WKC}
    rm -rf *
    cd ${WK}
@@ -44,27 +63,35 @@ def pre_test(){
 }
 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('python p1') {
+        stage('python') {
-          agent{label 'p1'}
+          agent{label 'pytest'}
          steps {
            pre_test()
            sh '''
            cd ${WKC}/tests
-            ./test-all.sh p1
+            ./test-all.sh pytest
            date'''
          }
        }
        stage('test_b1') {
          agent{label 'b1'}
-          steps {
+          steps {            
            pre_test()
            sh '''
            cd ${WKC}/tests
@@ -117,24 +144,10 @@ pipeline {
            date'''
          }
        }
-       stage('python p2'){
-         agent{label "p2"}
-         steps{
-            pre_test()         
-            sh '''
-            date
-            cd ${WKC}/tests
-            ./test-all.sh p2
-            date
-            '''
-         }
-       }
-      }
    }
  }
+  }
 }
--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -45,7 +45,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 ()
@@ -53,7 +53,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)
@@ -62,7 +62,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)
@@ -70,21 +70,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)
@@ -105,8 +105,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")
@@ -125,9 +125,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)
@@ -140,7 +140,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.10.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/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,35 +2,7 @@
 ## 快捷安装
-TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、mac OS等系统。
+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/#通过安装包安装)来安装。
-**应用驱动**
-如果应用在Windows和Linux上运行，可使用C/C++/C#/JAVA/Python/Go/Node.js接口连接服务器。如果应用在Mac上运行，目前可以使用RESTful接口连接服务器。
-**CPU**
-CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。
-**服务器**
-目前TDengine服务器可以运行在以下平台上：
-|                | **CentOS**  **6/7/8** | **Ubuntu**  **16/18/20** | **Other Linux** | **Win64/32** | **macOS** | **统信****UOS** | **银河****/****中标麒麟** | **凝思**  **V60/V80** |
-| -------------- | --------------------- | ------------------------ | --------------- | ------------ | --------- | --------------- | ------------------------- | --------------------- |
-| X64            | ●                     | ●                        |                 | ○/○          | ○         | ○               | ●                         | ●                     |
-| 树莓派ARM32    |                       | ●                        | ●               |              |           |                 |                           |                       |
-| 龙芯MIPS64     |                       |                          | ●               |              |           |                 |                           |                       |
-| 鲲鹏  ARM64    |                       | ○                        | ○               |              |           |                 | ●                         |                       |
-| 申威  Alpha64  |                       |                          | ○               |              |           | ●               |                           |                       |
-| 飞腾ARM64      |                       |                          | ○优麒麟         |              |           |                 |                           |                       |
-| 海光X64        | ●                     | ●                        | ●               |              |           | ○               | ●                         | ●                     |
-| 瑞芯微ARM64/32 |                       |                          | ○               |              |           |                 |                           |                       |
-| 全志ARM64/32   |                       |                          | ○               |              |           |                 |                           |                       |
-| 炬力ARM64/32   |                       |                          | ○               |              |           |                 |                           |                       |
-| TI ARM32       |                       |                          | ○               |              |           |                 |                           |                       |
 ### 通过源码安装
@@ -42,28 +14,11 @@ CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。
 ### 通过安装包安装
-服务器部分，我们提供三种安装包，您可以根据需要选择。TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。
+TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。服务端安装包包含客户端和连接器，我们提供三种安装包，您可以根据需要选择：
- TDengine-server-2.0.9.0-Linux-x64.rpm (4.2M)
- TDengine-server-2.0.9.0-Linux-x64.deb (2.7M)
- TDengine-server-2.0.9.0-Linux-x64.tar.gz (4.5M)
-客户端部分，Linux安装包如下：
- TDengine-client-2.0.9.0-Linux-x64.tar.gz(3.0M)
- TDengine-client-2.0.9.0-Windows-x64.exe(2.8M)
- TDengine-client-2.0.9.0-Windows-x86.exe(2.8M)
-报警模块的Linux安装包如下（请参考[报警模块的使用方法](https://github.com/taosdata/TDengine/blob/master/alert/README_cn.md)）：
- TDengine-alert-2.0.9.0-Linux-x64.tar.gz (8.1M)
-目前，TDengine 支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装，用`which systemctl`命令来检测系统中是否存在`systemd`包:
+- TDengine-server-2.0.10.0-Linux-x64.rpm (4.2M)
+- TDengine-server-2.0.10.0-Linux-x64.deb (2.7M)
-```cmd
+- TDengine-server-2.0.10.0-Linux-x64.tar.gz (4.5M)
-which systemctl
-```
 具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>。
@@ -71,13 +26,13 @@ which systemctl
 安装成功后，用户可使用`systemctl`命令来启动TDengine的服务进程。
-```cmd
+```bash
-systemctl start taosd
+$ systemctl start taosd
 ```
 检查服务是否正常工作。
-```cmd
+```bash
-systemctl status taosd
+$ systemctl status taosd
 ```
 如果TDengine服务正常工作，那么您可以通过TDengine的命令行程序`taos`来访问并体验TDengine。  
@@ -86,15 +41,24 @@ systemctl status taosd
 - 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 服务。
-如果系统中不支持`systemd`，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
 ## TDengine命令行程序
 执行TDengine命令行程序，您只要在Linux终端执行`taos`即可。
-```cmd
+```bash
-taos
+$ taos
 ```
 如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
@@ -134,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>;
 ```
@@ -157,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"。
@@ -169,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
@@ -8,14 +8,14 @@ TDengine采用关系型数据模型，需要建库、建表。因此对于一个
 不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为让各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
-```cmd
+```mysql
 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>  
 创建库之后，需要使用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
@@ -79,7 +79,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **使用数据库**
    ```mysql
    USE db_name;
    ```
@@ -1039,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。
@@ -97,6 +103,7 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 - 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都打开。
@@ -152,7 +159,13 @@ 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
+```
 客户端配置参数
@@ -215,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时间戳不受系统所在时区的影响。
@@ -239,31 +252,31 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
 系统管理员可以在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;
 ```
@@ -316,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>
@@ -334,7 +346,7 @@ TDengine提供了方便的数据库导入导出工具taosdump。用户可以将t
 如果用户需要导出一个表或一个STable中的数据，可在shell中运行
-```
+```mysql
 select * from <tb_name> >> data.csv;
 ```
@@ -348,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>;
 ```

--- 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
@@ -6,18 +6,23 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、C# 、J
 目前TDengine的连接器可支持的平台广泛，目前包括：X64/X86/ARM64/ARM32/MIPS/Alpha等硬件平台，以及Linux/Win64/Win32等开发环境。对照矩阵如下：
-|                              | **CPU**   | **X64   64bit** | **X86   32bit** | **ARM64** | **ARM32** | **MIPS **  **龙芯** | **Alpha **  **申威** | **X64 **  **海光** |           |           |
+| **CPU**     | **X64   64bit** | **X64   64bit** | **X64   64bit** | **X86   32bit** | **ARM64** | **ARM32** | **MIPS   龙芯** | **Alpha   申威** | **X64   海光** |
-| ---------------------------- | --------- | --------------- | --------------- | --------- | --------- | ------------------- | -------------------- | ------------------ | --------- | --------- |
+| ----------- | --------------- | --------------- | --------------- | --------------- | --------- | --------- | --------------- | ---------------- | -------------- |
-|                              | **OS**    | **Linux**       | **Win64**       | **Win32** | **Win32** | **Linux**           | **Linux**            | **Linux**          | **Linux** | **Linux** |
+| **OS**      | **Linux**       | **Win64**       | **Win32**       | **Win32**       | **Linux** | **Linux** | **Linux**       | **Linux**        | **Linux**      |
-| **连**     **接**     **器** | **C/C++** | ●               | ●               | ●         | ○         | ●                   | ●                    | ●                  | ●         | ●         |
+| **C/C++**   | ●               | ●               | ●               | ○               | ●         | ●         | ●               | ●                | ●              |
-| **JDBC**                     | ●         | ●               | ●               | ○         | ●         | ●                   | ●                    | ●                  | ●         |           |
+| **JDBC**    | ●               | ●               | ●               | ○               | ●         | ●         | ●               | ●                | ●              |
-| **Python**                   | ●         | ●               | ●               | ○         | ●         | ●                   | ●                    | --                 | ●         |           |
+| **Python**  | ●               | ●               | ●               | ○               | ●         | ●         | ●               | --               | ●              |
-| **Go**                       | ●         | ●               | ●               | ○         | ●         | ●                   | ○                    | --                 | --        |           |
+| **Go**      | ●               | ●               | ●               | ○               | ●         | ●         | ○               | --               | --             |
-| **NodeJs**                   | ●         | ●               | ○               | ○         | ●         | ●                   | ○                    | --                 | --        |           |
+| **NodeJs**  | ●               | ●               | ○               | ○               | ●         | ●         | ○               | --               | --             |
-| **C#**                       | ○         | ●               | ●               | ○         | ○         | ○                   | ○                    | --                 | --        |           |
+| **C#**      | ○               | ●               | ●               | ○               | ○         | ○         | ○               | --               | --             |
-| **RESTful**                  | ●         | ●               | ●               | ●         | ●         | ●                   | ●                    | ●                  | ●         |           |
+| **RESTful** | ●               | ●               | ●               | ●               | ●         | ●         | ●               | ●                | ●              |
-注意：所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+其中 ● 表示经过官方测试验证， ○ 表示非官方测试验证。
+注意：
+* 所有执行 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
@@ -300,7 +305,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
 ### 安装准备
 * 已安装TDengine, 如果客户端在Windows上，需要安装Windows 版本的TDengine客户端 [（Windows TDengine 客户端安装）][4]
 * 已安装python 2.7 or >= 3.4
-* 已安装pip
+* 已安装pip 或 pip3
 ### Python客户端安装
@@ -312,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> 命令行界面
@@ -472,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
 ```
@@ -488,7 +493,7 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 返回值为JSON格式，如下:
-```
+```json
 {
    "status": "succ",
    "head": ["Time Stamp","current", …],
@@ -511,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>
 ```
@@ -525,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,
@@ -543,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"],
@@ -562,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"],
@@ -582,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"],
@@ -603,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"],
@@ -724,7 +729,7 @@ TDengine 同时也提供了node.js 的连接器。用户可以通过[npm](https:
 首先，通过[npm](https://www.npmjs.com/)安装node.js 连接器.
-```cmd
+```bash
 npm install td2.0-connector
 ```
 我们建议用户使用npm 安装node.js连接器。如果您没有安装npm, 可以将*src/connector/nodejs/*拷贝到您的nodejs 项目目录下

--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/webdocs/markdowndocs/insert-ch.md
@@ -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/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.10.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.10.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/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -234,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);
@@ -287,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
@@ -229,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
@@ -246,7 +246,7 @@ typedef struct {
  int8_t       dataSourceType;     // load data from file or not
  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
  STableMeta **pTableMetaList; // all involved tableMeta list of current insert sql statement.
  int32_t      numOfTables;
@@ -285,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 {

--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -381,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);
@@ -390,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);

--- 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);
@@ -2884,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);

--- 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/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -796,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);
@@ -809,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) {
@@ -946,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);
@@ -972,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;
    }
@@ -983,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);
@@ -1298,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);
@@ -1363,7 +1356,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
      ret = tscToSQLCmd(pSql, &SQLInfo);
    }
-    SQLInfoDestroy(&SQLInfo);
+    SqlInfoDestroy(&SQLInfo);
  }
  /*
@@ -1529,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/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -147,15 +147,15 @@ 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);
      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]);
+          tscTrace("endpoint %d: fqdn=%s, port=%d", i, epSet->fqdn[i], epSet->port[i]);
        }
        tscUpdateMgmtEpSet(pSql, epSet);
      }
@@ -167,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) {
@@ -297,7 +326,9 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
       rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID ||
       rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL ||
       rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
-    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);
    pSql->res.code = rpcMsg->code;  // keep the previous error code
    if (pSql->retry > pSql->maxRetry) {
@@ -1240,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);
  }
@@ -1273,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);
@@ -1316,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;
    }
  }
@@ -1593,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);
@@ -2099,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);
@@ -2145,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;
 }
@@ -2256,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);
@@ -2283,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);
@@ -2326,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);
 }
@@ -2353,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/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);
@@ -2151,7 +2151,7 @@ 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)
+    tscError("%p max retry reached, abort the retry effort", pParentObj);
    return false;
  }
@@ -2209,10 +2209,10 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int 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);
-    doFreeInsertSupporter(pParentObj);
    // todo remove this parameter in async callback function definition.
    // all data has been sent to vnode, call user function
@@ -2220,7 +2220,6 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
    (*pParentObj->fp)(pParentObj->param, pParentObj, v);
  } else {
    if (!needRetryInsert(pParentObj, numOfSub)) {
-      doFreeInsertSupporter(pParentObj);
      tscQueueAsyncRes(pParentObj);
      return;
    }
@@ -2257,13 +2256,14 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
    // 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++);
+    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;
-      doFreeInsertSupporter(pParentObj);
      tscQueueAsyncRes(pParentObj);
      return;
    }
@@ -2279,7 +2279,6 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
 */
 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;
@@ -2288,9 +2287,6 @@ int32_t tscHandleInsertRetry(SSqlObj* pParent, SSqlObj* pSql) {
  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(pParent->cmd.pDataBlocks);
  if ((pRes->code = code)!= TSDB_CODE_SUCCESS) {
    tscQueueAsyncRes(pSql);
    return code;  // here the pSql may have been released already.
@@ -2307,7 +2303,11 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
  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);
@@ -2503,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
@@ -518,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);
@@ -1937,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) {
@@ -2580,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);
@@ -2592,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/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -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  tsRetrieveBlockingModel;         // 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[];
@@ -175,7 +177,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;
@@ -185,7 +187,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
@@ -25,7 +25,6 @@
 #include "tutil.h"
 #include "tlocale.h"
 #include "ttimezone.h"
-#include "tsync.h"
 // cluster
 char     tsFirst[TSDB_EP_LEN] = {0};
@@ -110,6 +109,9 @@ int32_t tsQueryBufferSize = -1;
 // in retrieve blocking model, the retrieve threads will wait for the completion of the query processing.
 int32_t tsRetrieveBlockingModel = 0;
+// last_row(*), first(*), last_row(ts, col1, col2) query, the result fields will be the original column name
+int32_t tsKeepOriginalColumnName = 0;
 // db parameters
 int32_t tsCacheBlockSize = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
 int32_t tsBlocksPerVnode = TSDB_DEFAULT_TOTAL_BLOCKS;
@@ -169,14 +171,14 @@ int32_t tsEnableStream = 1;
 // internal
 int32_t tsPrintAuth = 0;
-int32_t tscEmbedded = 0;
+uint32_t tscEmbedded = 0;
-char    configDir[TSDB_FILENAME_LEN] = {0};
+char     configDir[TSDB_FILENAME_LEN] = {0};
-char    tsVnodeDir[TSDB_FILENAME_LEN] = {0};
+char     tsVnodeDir[TSDB_FILENAME_LEN] = {0};
-char    tsDnodeDir[TSDB_FILENAME_LEN] = {0};
+char     tsDnodeDir[TSDB_FILENAME_LEN] = {0};
-char    tsMnodeDir[TSDB_FILENAME_LEN] = {0};
+char     tsMnodeDir[TSDB_FILENAME_LEN] = {0};
-char    tsDataDir[TSDB_FILENAME_LEN] = {0};
+char     tsDataDir[TSDB_FILENAME_LEN] = {0};
-char    tsScriptDir[TSDB_FILENAME_LEN] = {0};
+char     tsScriptDir[TSDB_FILENAME_LEN] = {0};
-char    tsVnodeBakDir[TSDB_FILENAME_LEN] = {0};
+char     tsVnodeBakDir[TSDB_FILENAME_LEN] = {0};
 /*
 * minimum scale for whole system, millisecond by default
@@ -207,13 +209,13 @@ int32_t mDebugFlag = 131;
 int32_t sdbDebugFlag = 131;
 int32_t dDebugFlag = 135;
 int32_t vDebugFlag = 135;
-int32_t cDebugFlag = 131;
+uint32_t cDebugFlag = 131;
 int32_t jniDebugFlag = 131;
 int32_t odbcDebugFlag = 131;
 int32_t httpDebugFlag = 131;
 int32_t mqttDebugFlag = 131;
 int32_t monDebugFlag = 131;
-int32_t qDebugFlag = 131;
+uint32_t qDebugFlag = 131;
 int32_t rpcDebugFlag = 131;
 int32_t uDebugFlag = 131;
 int32_t debugFlag = 0;
@@ -897,6 +899,16 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
+  cfg.option = "keepColumnName";
+  cfg.ptr = &tsKeepOriginalColumnName;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 1;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
  // locale & charset
  cfg.option = "timezone";
  cfg.ptr = tsTimezone;

--- 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
@@ -97,7 +97,7 @@ void *cqOpen(void *ahandle, const SCqCfg *pCfg) {
  pthread_mutex_init(&pContext->mutex, NULL);
-  cInfo("vgId:%d, CQ is opened", pContext->vgId);
+  cDebug("vgId:%d, CQ is opened", pContext->vgId);
  return pContext;
 }
@@ -131,7 +131,7 @@ void cqClose(void *handle) {
  taosTmrCleanUp(pContext->tmrCtrl);
  pContext->tmrCtrl = NULL;
-  cInfo("vgId:%d, CQ is closed", pContext->vgId);
+  cDebug("vgId:%d, CQ is closed", pContext->vgId);
  free(pContext);
 }
@@ -142,7 +142,7 @@ void cqStart(void *handle) {
  SCqContext *pContext = handle;
  if (pContext->dbConn || pContext->master) return;
-  cInfo("vgId:%d, start all CQs", pContext->vgId);
+  cDebug("vgId:%d, start all CQs", pContext->vgId);
  pthread_mutex_lock(&pContext->mutex);
  pContext->master = 1;
@@ -298,7 +298,7 @@ static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
    if (pObj->pStream) {
      tscSetStreamDestTable(pObj->pStream, pObj->dstTable);
      pContext->num++;
-      cInfo("vgId:%d, id:%d CQ:%s is openned", pContext->vgId, pObj->tid, pObj->sqlStr);
+      cDebug("vgId:%d, id:%d CQ:%s is opened", pContext->vgId, pObj->tid, pObj->sqlStr);
    } else {
      cError("vgId:%d, id:%d CQ:%s, failed to open", pContext->vgId, pObj->tid, pObj->sqlStr);
    }

--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
@@ -147,6 +147,7 @@ int32_t dnodeInitSystem() {
  dnodeSetRunStatus(TSDB_RUN_STATUS_RUNING);
+  dnodeReportStep("TDengine", "initialized successfully", 1);
  dInfo("TDengine is initialized successfully");
  return 0;

--- a/src/dnode/src/dnodeStep.c
+++ b/src/dnode/src/dnodeStep.c
@@ -57,12 +57,13 @@ int32_t dnodeStepInit(SStep *pSteps, int32_t stepSize) {
    int32_t code = (*pStep->initFp)();
    if (code != 0) {
-      dDebug("step:%s will init", pStep->name);
+      dDebug("step:%s will cleanup", pStep->name);
      taosStepCleanupImp(pSteps, step);
      return code;
    }
+    dInfo("step:%s is initialized", pStep->name);
-    dnodeReportStep(pStep->name, "Initialization complete", step + 1 >= stepSize);
+    dnodeReportStep(pStep->name, "Initialization complete", 0);
  }
  return 0;

--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
@@ -33,6 +33,8 @@ typedef struct {
 extern void *   tsDnodeTmr;
 static void *   tsStatusTimer = NULL;
 static uint32_t tsRebootTime = 0;
+static int32_t  tsOpenVnodes = 0;
+static int32_t  tsTotalVnodes = 0;
 static void dnodeSendStatusMsg(void *handle, void *tmrId);
 static void dnodeProcessStatusRsp(SRpcMsg *pMsg);
@@ -84,21 +86,27 @@ static int32_t dnodeGetVnodeList(int32_t vnodeList[], int32_t *numOfVnodes) {
 static void *dnodeOpenVnode(void *param) {
  SOpenVnodeThread *pThread = param;
+  char stepDesc[TSDB_STEP_DESC_LEN] = {0};
  dDebug("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
  for (int32_t v = 0; v < pThread->vnodeNum; ++v) {
    int32_t vgId = pThread->vnodeList[v];
+    snprintf(stepDesc, TSDB_STEP_DESC_LEN, "vgId:%d, start to restore, %d of %d have been opened", vgId, tsOpenVnodes, tsTotalVnodes);
+    dnodeReportStep("open-vnodes", stepDesc, 0);
    if (vnodeOpen(vgId) < 0) {
      dError("vgId:%d, failed to open vnode by thread:%d", vgId, pThread->threadIndex);
      pThread->failed++;
    } else {
-      dDebug("vgId:%d, is openned by thread:%d", vgId, pThread->threadIndex);
+      dDebug("vgId:%d, is opened by thread:%d", vgId, pThread->threadIndex);
      pThread->opened++;
    }
+    atomic_add_fetch_32(&tsOpenVnodes, 1);
  }
-  dDebug("thread:%d, total vnodes:%d, openned:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened,
+  dDebug("thread:%d, total vnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened,
         pThread->failed);
  return NULL;
 }
@@ -107,6 +115,7 @@ int32_t dnodeInitVnodes() {
  int32_t vnodeList[TSDB_MAX_VNODES] = {0};
  int32_t numOfVnodes = 0;
  int32_t status = dnodeGetVnodeList(vnodeList, &numOfVnodes);
+  tsTotalVnodes = numOfVnodes;
  if (status != TSDB_CODE_SUCCESS) {
    dInfo("get dnode list failed");
@@ -127,7 +136,7 @@ int32_t dnodeInitVnodes() {
    pThread->vnodeList[pThread->vnodeNum++] = vnodeList[v];
  }
-  dDebug("start %d threads to open %d vnodes", threadNum, numOfVnodes);
+  dInfo("start %d threads to open %d vnodes", threadNum, numOfVnodes);
  for (int32_t t = 0; t < threadNum; ++t) {
    SOpenVnodeThread *pThread = &threads[t];
@@ -156,7 +165,7 @@ int32_t dnodeInitVnodes() {
  }
  free(threads);
-  dInfo("there are total vnodes:%d, openned:%d", numOfVnodes, openVnodes);
+  dInfo("there are total vnodes:%d, opened:%d", numOfVnodes, openVnodes);
  if (failedVnodes != 0) {
    dError("there are total vnodes:%d, failed:%d", numOfVnodes, failedVnodes);

--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -266,6 +266,13 @@ TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_CONFIG,           0, 0x0900, "Invalid Sy
 TAOS_DEFINE_ERROR(TSDB_CODE_SYN_NOT_ENABLED,              0, 0x0901, "Sync module not enabled")
 TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_VERSION,          0, 0x0902, "Invalid Sync version")
 TAOS_DEFINE_ERROR(TSDB_CODE_SYN_CONFIRM_EXPIRED,          0, 0x0903, "Sync confirm expired")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_TOO_MANY_FWDINFO,         0, 0x0904, "Too many sync fwd infos")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_MISMATCHED_PROTOCOL,      0, 0x0905, "Mismatched protocol")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_MISMATCHED_CLUSTERID,     0, 0x0906, "Mismatched clusterId")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_MISMATCHED_SIGNATURE,     0, 0x0907, "Mismatched signature")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_CHECKSUM,         0, 0x0908, "Invalid msg checksum")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_MSGLEN,           0, 0x0909, "Invalid msg length")
+TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_MSGTYPE,          0, 0x090A, "Invalid msg type")
 // wal
 TAOS_DEFINE_ERROR(TSDB_CODE_WAL_APP_ERROR,                0, 0x1000, "Unexpected generic error in wal")

--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -266,6 +266,7 @@ typedef struct {
 } SMDCreateTableMsg;
 typedef struct {
+  int32_t len;  // one create table message
  char    tableId[TSDB_TABLE_FNAME_LEN];
  char    db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
  int8_t  igExists;
@@ -273,9 +274,13 @@ typedef struct {
  int16_t numOfTags;
  int16_t numOfColumns;
  int16_t sqlLen;  // the length of SQL, it starts after schema , sql is a null-terminated string
-  int32_t contLen;
  int8_t  reserved[16];
  char    schema[];
+} SCreateTableMsg;
+typedef struct {
+  int32_t numOfTables;
+  int32_t contLen;
 } SCMCreateTableMsg;
 typedef struct {
@@ -730,8 +735,8 @@ typedef struct SMultiTableMeta {
 typedef struct {
  int32_t dataLen;
-  char name[TSDB_TABLE_FNAME_LEN];
+  char    name[TSDB_TABLE_FNAME_LEN];
-  char data[TSDB_MAX_TAGS_LEN + TD_KV_ROW_HEAD_SIZE + sizeof(SColIdx) * TSDB_MAX_TAGS];
+  char   *data;
 } STagData;
 /*

--- a/src/inc/tsync.h
+++ b/src/inc/tsync.h
@@ -119,11 +119,6 @@ int32_t syncGetNodesRole(int64_t rid, SNodesRole *);
 extern char *syncRole[];
 //global configurable parameters
-extern int32_t  tsMaxSyncNum;
-extern int32_t  tsSyncTcpThreads;
-extern int32_t  tsMaxWatchFiles;
-extern int32_t  tsSyncTimer;
-extern int32_t  tsMaxFwdInfo;
 extern int32_t  sDebugFlag;
 extern char     tsArbitrator[];
 extern uint16_t tsSyncPort;

--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -8,25 +8,26 @@ extern "C" {
 #include "taosdef.h"
 #define GET_TYPED_DATA(_v, _finalType, _type, _data) \
-  switch (_type) {                       \
+  switch (_type) {                                   \
-    case TSDB_DATA_TYPE_TINYINT:         \
+    case TSDB_DATA_TYPE_BOOL:                        \
+    case TSDB_DATA_TYPE_TINYINT:                     \
      (_v) = (_finalType)GET_INT8_VAL(_data);        \
-      break;                             \
+      break;                                         \
-    case TSDB_DATA_TYPE_SMALLINT:        \
+    case TSDB_DATA_TYPE_SMALLINT:                    \
      (_v) = (_finalType)GET_INT16_VAL(_data);       \
-      break;                             \
+      break;                                         \
-    case TSDB_DATA_TYPE_BIGINT:          \
+    case TSDB_DATA_TYPE_BIGINT:                      \
      (_v) = (_finalType)(GET_INT64_VAL(_data));     \
-      break;                             \
+      break;                                         \
-    case TSDB_DATA_TYPE_FLOAT:           \
+    case TSDB_DATA_TYPE_FLOAT:                       \
      (_v) = (_finalType)GET_FLOAT_VAL(_data);       \
-      break;                             \
+      break;                                         \
-    case TSDB_DATA_TYPE_DOUBLE:          \
+    case TSDB_DATA_TYPE_DOUBLE:                      \
      (_v) = (_finalType)GET_DOUBLE_VAL(_data);      \
-      break;                             \
+      break;                                         \
-    default:                             \
+    default:                                         \
      (_v) = (_finalType)GET_INT32_VAL(_data);       \
-      break;                             \
+      break;                                         \
  };
 #ifdef __cplusplus

--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
@@ -48,7 +48,7 @@ typedef struct {
  void *   pVnode;
  SRpcMsg  rpcMsg;
  SRspRet  rspRet;
-  char     reserveForSync[16];
+  char     reserveForSync[24];
  SWalHead pHead[];
 } SVWriteMsg;

--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
@@ -86,6 +86,6 @@ extern void           set_terminal_mode();
 extern int get_old_terminal_mode(struct termios* tio);
 extern void            reset_terminal_mode();
 extern SShellArguments args;
-extern TAOS_RES*       result;
+extern int64_t         result;
 #endif
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -46,7 +46,7 @@ char      CONTINUE_PROMPT[] = "   -> ";
 int       prompt_size = 6;
 #endif
-TAOS_RES *result = NULL;
+int64_t result = 0;
 SShellHistory   history;
 #define DEFAULT_MAX_BINARY_DISPLAY_WIDTH 30
@@ -260,6 +260,14 @@ int32_t shellRunCommand(TAOS* con, char* command) {
 }
+void freeResultWithRid(int64_t rid) {
+  SSqlObj* pSql = taosAcquireRef(tscObjRef, rid);
+  if(pSql){
+    taos_free_result(pSql);
+    taosReleaseRef(tscObjRef, rid);
+  }
+}
 void shellRunCommandOnServer(TAOS *con, char command[]) {
  int64_t   st, et;
  wordexp_t full_path;
@@ -294,18 +302,22 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
  st = taosGetTimestampUs();
-  TAOS_RES* pSql = taos_query_h(con, command, &result);
+  TAOS_RES* tmpSql = NULL;
+  TAOS_RES* pSql = taos_query_h(con, command, &tmpSql);
  if (taos_errno(pSql)) {
    taos_error(pSql, st);
    return;
  }
+  atomic_store_64(&result, ((SSqlObj*)tmpSql)->self);
+  int64_t oresult = atomic_load_64(&result);
  if (regex_match(command, "^\\s*use\\s+[a-zA-Z0-9_]+\\s*;\\s*$", REG_EXTENDED | REG_ICASE)) {
    fprintf(stdout, "Database changed.\n\n");
    fflush(stdout);
-    atomic_store_ptr(&result, 0);
+    atomic_store_64(&result, 0);
-    taos_free_result(pSql);
+    freeResultWithRid(oresult);
    return;
  }
@@ -313,8 +325,8 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
    int error_no = 0;
    int numOfRows = shellDumpResult(pSql, fname, &error_no, printMode);
    if (numOfRows < 0) {
-      atomic_store_ptr(&result, 0);
+      atomic_store_64(&result, 0);
-      taos_free_result(pSql);
+      freeResultWithRid(oresult);
      return;
    }
@@ -336,8 +348,8 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
    wordfree(&full_path);
  }
-  atomic_store_ptr(&result, 0);
+  atomic_store_64(&result, 0);
-  taos_free_result(pSql);
+  freeResultWithRid(oresult);
 }
 /* Function to do regular expression check */
@@ -501,7 +513,7 @@ static int dumpResultToFile(const char* fname, TAOS_RES* tres) {
    row = taos_fetch_row(tres);
  } while( row != NULL);
-  result = NULL;
+  result = 0;
  fclose(fp);
  return numOfRows;

--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -33,7 +33,7 @@ const char *argp_program_bug_address = "<support@taosdata.com>";
 static char doc[] = "";
 static char args_doc[] = "";
 static struct argp_option options[] = {
-  {"host",       'h', "HOST",       0,                   "TDengine server IP address to connect. The default host is localhost."},
+  {"host",       'h', "HOST",       0,                   "TDengine server FQDN to connect. The default host is localhost."},
  {"password",   'p', "PASSWORD",   OPTION_ARG_OPTIONAL, "The password to use when connecting to the server."},
  {"port",       'P', "PORT",       0,                   "The TCP/IP port number to use for the connection."},
  {"user",       'u', "USER",       0,                   "The user name to use when connecting to the server."},

--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
@@ -19,15 +19,31 @@
 #include "tnettest.h"
 pthread_t pid;
+static tsem_t cancelSem;
 void shellQueryInterruptHandler(int signum) {
+  tsem_post(&cancelSem);
+}
+void *cancelHandler(void *arg) {
+  while(1) {
+    if (tsem_wait(&cancelSem) != 0) {
+      taosMsleep(10);
+      continue;
+    }
 #ifdef LINUX
-  void* pResHandle = atomic_val_compare_exchange_64(&result, result, 0);
+    int64_t rid = atomic_val_compare_exchange_64(&result, result, 0);
-  taos_stop_query(pResHandle);
+    SSqlObj* pSql = taosAcquireRef(tscObjRef, rid);
+    taos_stop_query(pSql);
+    taosReleaseRef(tscObjRef, rid);
 #else
-  printf("\nReceive ctrl+c or other signal, quit shell.\n");
+    printf("\nReceive ctrl+c or other signal, quit shell.\n");
-  exit(0);
+    exit(0);
 #endif
+  }
+  return NULL;
 }
 int checkVersion() {
@@ -105,6 +121,14 @@ int main(int argc, char* argv[]) {
    exit(EXIT_FAILURE);
  }
+  if (tsem_init(&cancelSem, 0, 0) != 0) {
+    printf("failed to create cancel semphore\n");
+    exit(EXIT_FAILURE);
+  }
+  pthread_t spid;
+  pthread_create(&spid, NULL, cancelHandler, NULL);
  /* Interrupt handler. */
  struct sigaction act;
  memset(&act, 0, sizeof(struct sigaction));

--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
@@ -24,7 +24,7 @@ void printHelp() {
  printf("taos shell is used to test the TDengine database\n");
  printf("%s%s\n", indent, "-h");
-  printf("%s%s%s\n", indent, indent, "TDengine server IP address to connect. The default host is localhost.");
+  printf("%s%s%s\n", indent, indent, "TDengine server FQDN to connect. The default host is localhost.");
  printf("%s%s\n", indent, "-p");
  printf("%s%s%s\n", indent, indent, "The password to use when connecting to the server.");
  printf("%s%s\n", indent, "-P");

--- a/src/mnode/inc/mnodeSdb.h
+++ b/src/mnode/inc/mnodeSdb.h
@@ -59,7 +59,7 @@ typedef struct SSdbRow {
  SMnodeMsg *pMsg;
  int32_t  (*fpReq)(SMnodeMsg *pMsg);
  int32_t  (*fpRsp)(SMnodeMsg *pMsg, int32_t code);
-  char       reserveForSync[16];
+  char       reserveForSync[24];
  SWalHead   pHead[];
 } SSdbRow;

--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -104,7 +104,7 @@ static int32_t mnodeDnodeActionInsert(SSdbRow *pRow) {
  dnodeUpdateEp(pDnode->dnodeId, pDnode->dnodeEp, pDnode->dnodeFqdn, &pDnode->dnodePort);
  mnodeUpdateDnodeEps();
-  mInfo("dnode:%d, fqdn:%s ep:%s port:%d, do insert action", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp, pDnode->dnodePort);
+  mInfo("dnode:%d, fqdn:%s ep:%s port:%d is created", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp, pDnode->dnodePort);
  return TSDB_CODE_SUCCESS;
 }

--- a/src/mnode/src/mnodeMain.c
+++ b/src/mnode/src/mnodeMain.c
@@ -91,6 +91,7 @@ int32_t mnodeStartSystem() {
    return -1;
  }
+  dnodeReportStep("mnode-grant", "start to set grant infomation", 0);
  grantReset(TSDB_GRANT_ALL, 0);
  tsMgmtIsRunning = true;

--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
@@ -72,7 +72,7 @@ static int32_t mnodeMnodeActionInsert(SSdbRow *pRow) {
  pDnode->isMgmt = true;
  mnodeDecDnodeRef(pDnode);
-  mInfo("mnode:%d, fqdn:%s ep:%s port:%u, do insert action", pMnode->mnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp,
+  mInfo("mnode:%d, fqdn:%s ep:%s port:%u is created", pMnode->mnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp,
        pDnode->dnodePort);
  return TSDB_CODE_SUCCESS;
 }
@@ -202,13 +202,13 @@ void mnodeCancelGetNextMnode(void *pIter) {
 void mnodeUpdateMnodeEpSet(SMInfos *pMinfos) {
  bool    set = false;
  SMInfos mInfos = {0};
-  mInfo("vgId:1, update mnodes epSet, numOfMnodes:%d pMinfos:%p", mnodeGetMnodesNum(), pMinfos);
  if (pMinfos != NULL) {
+    mInfo("vgId:1, update mnodes epSet, numOfMinfos:%d", pMinfos->mnodeNum);
    set = true;
    mInfos = *pMinfos;
-  }
+  } else {
-  else {
+    mInfo("vgId:1, update mnodes epSet, numOfMnodes:%d", mnodeGetMnodesNum());
    int32_t index = 0;
    void *  pIter = NULL;
    while (1) {
@@ -294,6 +294,11 @@ void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect) {
  *epSet = tsMEpForShell;
  mnodeMnodeUnLock();
+  if (mnodeGetDnodesNum() <= 1) {
+    epSet->numOfEps = 0;
+    return;
+  }
  mTrace("vgId:1, mnodes epSet for shell is returned, num:%d inUse:%d", tsMEpForShell.numOfEps, tsMEpForShell.inUse);
  for (int32_t i = 0; i < epSet->numOfEps; ++i) {
    if (redirect && strcmp(epSet->fqdn[i], tsLocalFqdn) == 0 && htons(epSet->port[i]) == tsServerPort) {

--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -183,18 +183,23 @@ static int32_t sdbInitWal() {
    return -1;
  }
-  sdbInfo("vgId:1, open wal for restore");
+  sdbInfo("vgId:1, open sdb wal for restore");
  int32_t code = walRestore(tsSdbMgmt.wal, NULL, sdbProcessWrite);
  if (code != TSDB_CODE_SUCCESS) {
    sdbError("vgId:1, failed to open wal for restore since %s", tstrerror(code));
    return -1;
  }
+  sdbInfo("vgId:1, sdb wal load success");
  return 0;
 }
 static void sdbRestoreTables() {
  int32_t totalRows = 0;
  int32_t numOfTables = 0;
+  sdbInfo("vgId:1, sdb start to check for integrity");
  for (int32_t tableId = 0; tableId < SDB_TABLE_MAX; ++tableId) {
    SSdbTable *pTable = sdbGetTableFromId(tableId);
    if (pTable == NULL) continue;
@@ -204,7 +209,7 @@ static void sdbRestoreTables() {
    totalRows += pTable->numOfRows;
    numOfTables++;
-    sdbDebug("vgId:1, sdb:%s is restored, rows:%" PRId64, pTable->name, pTable->numOfRows);
+    sdbInfo("vgId:1, sdb:%s is checked, rows:%" PRId64, pTable->name, pTable->numOfRows);
  }
  sdbInfo("vgId:1, sdb is restored, mver:%" PRIu64 " rows:%d tables:%d", tsSdbMgmt.version, totalRows, numOfTables);
@@ -628,6 +633,12 @@ static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *
  SSdbTable *pTable = sdbGetTableFromId(tableId);
  assert(pTable != NULL);
+  if (!mnodeIsRunning() && tsSdbMgmt.version % 100000 == 0) {
+    char stepDesc[TSDB_STEP_DESC_LEN] = {0};
+    snprintf(stepDesc, TSDB_STEP_DESC_LEN, "%" PRIu64 " rows have been restored", tsSdbMgmt.version);
+    dnodeReportStep("mnode-sdb", stepDesc, 0);
+  }
  if (qtype == TAOS_QTYPE_QUERY) return sdbPerformDeleteAction(pHead, pTable);
  pthread_mutex_lock(&tsSdbMgmt.mutex);

--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -49,12 +49,14 @@
 #define CREATE_CTABLE_RETRY_TIMES 10
 #define CREATE_CTABLE_RETRY_SEC   14
-int64_t        tsCTableRid = -1;
+int64_t          tsCTableRid = -1;
-static void *  tsChildTableSdb;
+static void *    tsChildTableSdb;
-int64_t        tsSTableRid = -1;
+int64_t          tsSTableRid = -1;
-static void *  tsSuperTableSdb;
+static void *    tsSuperTableSdb;
-static int32_t tsChildTableUpdateSize;
+static SHashObj *tsSTableUidHash;
-static int32_t tsSuperTableUpdateSize;
+static int32_t   tsChildTableUpdateSize;
+static int32_t   tsSuperTableUpdateSize;
 static void *  mnodeGetChildTable(char *tableId);
 static void *  mnodeGetSuperTable(char *tableId);
 static void *  mnodeGetSuperTableByUid(uint64_t uid);
@@ -289,6 +291,7 @@ static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
 }
 static int32_t mnodeChildTableActionRestored() {
+#if 0
  void *pIter = NULL;
  SCTableObj *pTable = NULL;
@@ -345,6 +348,7 @@ static int32_t mnodeChildTableActionRestored() {
  }
  mnodeCancelGetNextChildTable(pIter);
+#endif
  return 0;
 }
@@ -447,6 +451,7 @@ static int32_t mnodeSuperTableActionInsert(SSdbRow *pRow) {
  }
  mnodeDecDbRef(pDb);
+  taosHashPut(tsSTableUidHash, &pStable->uid, sizeof(int64_t), &pStable, sizeof(int64_t));
  return TSDB_CODE_SUCCESS;
 }
@@ -459,6 +464,7 @@ static int32_t mnodeSuperTableActionDelete(SSdbRow *pRow) {
  }
  mnodeDecDbRef(pDb);
+  taosHashRemove(tsSTableUidHash, &pStable->uid, sizeof(int64_t));
  return TSDB_CODE_SUCCESS;
 }
@@ -570,6 +576,7 @@ static int32_t mnodeInitSuperTables() {
    .fpRestored   = mnodeSuperTableActionRestored
  };
+  tsSTableUidHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
  tsSTableRid = sdbOpenTable(&desc);
  tsSuperTableSdb = sdbGetTableByRid(tsSTableRid);
  if (tsSuperTableSdb == NULL) {
@@ -584,6 +591,9 @@ static int32_t mnodeInitSuperTables() {
 static void mnodeCleanupSuperTables() {
  sdbCloseTable(tsSTableRid);
  tsSuperTableSdb = NULL;
+  taosHashCleanup(tsSTableUidHash);
+  tsSTableUidHash = NULL;
 }
 int32_t mnodeInitTables() {
@@ -633,20 +643,12 @@ static void *mnodeGetSuperTable(char *tableId) {
 }
 static void *mnodeGetSuperTableByUid(uint64_t uid) {
-  SSTableObj *pStable = NULL;
+  SSTableObj **ppStable = taosHashGet(tsSTableUidHash, &uid, sizeof(int64_t));
-  void *pIter = NULL;
+  if (ppStable == NULL || *ppStable == NULL) return NULL;
-  while (1) {
+  SSTableObj *pStable = *ppStable;
-    pIter = mnodeGetNextSuperTable(pIter, &pStable);
+  mnodeIncTableRef(pStable);
-    if (pStable == NULL) break;
+  return pStable;
-    if (pStable->uid == uid) {
-      mnodeCancelGetNextSuperTable(pIter);
-      return pStable;
-    }
-    mnodeDecTableRef(pStable);
-  }
-  return NULL;
 }
 void *mnodeGetTable(char *tableId) {
@@ -720,10 +722,17 @@ static void mnodeExtractTableName(char* tableId, char* name) {
 static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db);
+  int32_t numOfTables = htonl(pCreate->numOfTables);
+  int32_t contentLen = htonl(pCreate->contLen);
+  if (numOfTables == 0 || contentLen == 0) {
+    // todo return error
+  }
+  SCreateTableMsg *p = (SCreateTableMsg*)((char*) pCreate + sizeof(SCMCreateTableMsg));
+  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(p->db);
  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
    return TSDB_CODE_MND_DB_NOT_SELECTED;
  }
@@ -732,28 +741,28 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
    return TSDB_CODE_MND_DB_IN_DROPPING;
  }
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId);
+  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(p->tableId);
  if (pMsg->pTable != NULL && pMsg->retry == 0) {
-    if (pCreate->getMeta) {
+    if (p->getMeta) {
-      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
      return mnodeGetChildTableMeta(pMsg);
-    } else if (pCreate->igExists) {
+    } else if (p->igExists) {
-      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
      return TSDB_CODE_SUCCESS;
    } else {
      mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId);
+             p->tableId);
      return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
    }
  }
-  if (pCreate->numOfTags != 0) {
+  if (p->numOfTags != 0) {
    mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreate->tableId, pMsg->rpcMsg.handle);
+           p->tableId, pMsg->rpcMsg.handle);
    return mnodeProcessCreateSuperTableMsg(pMsg);
  } else {
    mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreate->tableId, pMsg->rpcMsg.handle);
+           p->tableId, pMsg->rpcMsg.handle);
    return mnodeProcessCreateChildTableMsg(pMsg);
  }
 }
@@ -859,7 +868,13 @@ static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
 static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
  if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
+  if (pCreate1->numOfTables == 0) {
+    // todo return to error message
+  }
+  SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
  SSTableObj *   pStable = calloc(1, sizeof(SSTableObj));
  if (pStable == NULL) {
    mError("msg:%p, app:%p table:%s, failed to create, no enough memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
@@ -1599,8 +1614,11 @@ static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) {
  mInfo("drop stable rsp received, result:%s", tstrerror(rpcMsg->code));
 }
-static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *pTable) {
+static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pCreateMsg, SCTableObj *pTable) {
-  STagData *  pTagData = NULL;
+  SCreateTableMsg* pMsg = (SCreateTableMsg*) ((char*)pCreateMsg + sizeof(SCMCreateTableMsg));
+  char* tagData = NULL;
  int32_t tagDataLen = 0;
  int32_t totalCols = 0;
  int32_t contLen = 0;
@@ -1608,9 +1626,13 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
    totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
    contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
    if (pMsg != NULL) {
-      pTagData = (STagData *)pMsg->schema;
+      int32_t nameLen = htonl(*(int32_t*)pMsg->schema);
-      tagDataLen = htonl(pTagData->dataLen);
+      char* p = pMsg->schema + nameLen + sizeof(int32_t);
+      tagDataLen = htonl(*(int32_t*) p);
      contLen += tagDataLen;
+      tagData = p + sizeof(int32_t);
    }
  } else {
    totalCols = pTable->numOfColumns;
@@ -1662,7 +1684,7 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
  }
  if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
-    memcpy(pCreate->data + totalCols * sizeof(SSchema), pTagData->data, tagDataLen);
+    memcpy(pCreate->data + totalCols * sizeof(SSchema), tagData, tagDataLen);
  }
  if (pTable->info.type == TSDB_STREAM_TABLE) {
@@ -1700,7 +1722,8 @@ static int32_t mnodeDoCreateChildTableFp(SMnodeMsg *pMsg) {
 static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCreateTableMsg *pCreate = (SCreateTableMsg*) ((char*)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
  assert(pTable);
  if (code == TSDB_CODE_SUCCESS) {
@@ -1728,40 +1751,42 @@ static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
 static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
  SVgObj *pVgroup = pMsg->pVgroup;
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCMCreateTableMsg *p1 = pMsg->rpcMsg.pCont;
+  SCreateTableMsg   *pCreate = (SCreateTableMsg*)((char*)p1 + sizeof(SCMCreateTableMsg));
  SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
  if (pTable == NULL) {
    mError("msg:%p, app:%p table:%s, failed to alloc memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
    return TSDB_CODE_MND_OUT_OF_MEMORY;
  }
-  if (pCreate->numOfColumns == 0) {
+  pTable->info.type    = (pCreate->numOfColumns == 0)? TSDB_CHILD_TABLE:TSDB_NORMAL_TABLE;
-    pTable->info.type = TSDB_CHILD_TABLE;
+  pTable->info.tableId = strdup(pCreate->tableId);
-  } else {
-    pTable->info.type = TSDB_NORMAL_TABLE;
-  }
-  pTable->info.tableId = strdup(pCreate->tableId);  
  pTable->createdTime  = taosGetTimestampMs();
  pTable->tid          = tid;
  pTable->vgId         = pVgroup->vgId;
  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    STagData *pTagData = (STagData *)pCreate->schema;  // it is a tag key
+    int32_t nameLen = htonl(*(int32_t*) pCreate->schema);
+    char* name = (char*)pCreate->schema + sizeof(int32_t);
+    char stableName[TSDB_TABLE_FNAME_LEN] = {0};
+    memcpy(stableName, name, nameLen);
    char prefix[64] = {0};
    size_t prefixLen = tableIdPrefix(pMsg->pDb->name, prefix, 64);
-    if (0 != strncasecmp(prefix, pTagData->name, prefixLen)) {
+    if (0 != strncasecmp(prefix, stableName, prefixLen)) {
      mError("msg:%p, app:%p table:%s, corresponding super table:%s not in this db", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId, pTagData->name);
+             pCreate->tableId, stableName);
      mnodeDestroyChildTable(pTable);
      return TSDB_CODE_TDB_INVALID_CREATE_TB_MSG;
    }
-    if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(pTagData->name);
+    if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(stableName);
    if (pMsg->pSTable == NULL) {
      mError("msg:%p, app:%p table:%s, corresponding super table:%s does not exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId, pTagData->name);
+             pCreate->tableId, stableName);
      mnodeDestroyChildTable(pTable);
      return TSDB_CODE_MND_INVALID_TABLE_NAME;
    }
@@ -1839,7 +1864,9 @@ static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
 }
 static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  //SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
+  SCreateTableMsg* pCreate = (SCreateTableMsg*)(pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
  int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
  if (code != TSDB_CODE_SUCCESS) {
    mError("msg:%p, app:%p table:%s, failed to create, grant timeseries failed", pMsg, pMsg->rpcMsg.ahandle,
@@ -2187,15 +2214,23 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
 static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-  STagData *pTags = (STagData *)pInfo->tags;
-  int32_t tagLen = htonl(pTags->dataLen);
+  char* p = pInfo->tags;
-  if (pTags->name[0] == 0) {
+  int32_t nameLen = htonl(*(int32_t*) p);
-    mError("msg:%p, app:%p table:%s, failed to create table on demand for stable is empty, tagLen:%d", pMsg,
+  p += sizeof(int32_t);
+  p += nameLen;
+  int32_t tagLen = htonl(*(int32_t*) p);
+  p += sizeof(int32_t);
+  int32_t totalLen = nameLen + tagLen + sizeof(int32_t)*2;
+  if (tagLen == 0 || nameLen == 0) {
+    mError("msg:%p, app:%p table:%s, failed to create table on demand for super table is empty, tagLen:%d", pMsg,
           pMsg->rpcMsg.ahandle, pInfo->tableId, tagLen);
    return TSDB_CODE_MND_INVALID_STABLE_NAME;
  }
-  int32_t contLen = sizeof(SCMCreateTableMsg) + offsetof(STagData, data) + tagLen;
+  int32_t contLen = sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg) + totalLen;
  SCMCreateTableMsg *pCreateMsg = calloc(1, contLen);
  if (pCreateMsg == NULL) {
    mError("msg:%p, app:%p table:%s, failed to create table while get meta info, no enough memory", pMsg,
@@ -2203,16 +2238,24 @@ static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
    return TSDB_CODE_MND_OUT_OF_MEMORY;
  }
-  size_t size = sizeof(pInfo->tableId);
+  SCreateTableMsg* pCreate = (SCreateTableMsg*) ((char*) pCreateMsg + sizeof(SCMCreateTableMsg));
-  tstrncpy(pCreateMsg->tableId, pInfo->tableId, size);
-  tstrncpy(pCreateMsg->db, pMsg->pDb->name, sizeof(pCreateMsg->db));
+  size_t size = tListLen(pInfo->tableId);
-  pCreateMsg->igExists = 1;
+  tstrncpy(pCreate->tableId, pInfo->tableId, size);
-  pCreateMsg->getMeta = 1;
+  tstrncpy(pCreate->db, pMsg->pDb->name, sizeof(pCreate->db));
+  pCreate->igExists = 1;
+  pCreate->getMeta = 1;
+  pCreateMsg->numOfTables = htonl(1);
  pCreateMsg->contLen = htonl(contLen);
-  memcpy(pCreateMsg->schema, pTags, contLen - sizeof(SCMCreateTableMsg));
+  memcpy(pCreate->schema, pInfo->tags, totalLen);
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  memcpy(name, pInfo->tags + sizeof(int32_t), nameLen);
  mDebug("msg:%p, app:%p table:%s, start to create on demand, tagLen:%d stable:%s", pMsg, pMsg->rpcMsg.ahandle,
-         pInfo->tableId, tagLen, pTags->name);
+         pInfo->tableId, tagLen, name);
  if (pMsg->rpcMsg.pCont != pMsg->pCont) {
    tfree(pMsg->rpcMsg.pCont);

--- a/src/os/inc/osMemory.h
+++ b/src/os/inc/osMemory.h
@@ -52,7 +52,7 @@ void   taosTMemset(void *ptr, int c);
      free((void *)(x)); \
      x = 0;             \
    }                    \
-  } while (0);
+  } while (0)
 #ifdef TAOS_MEM_CHECK
  #ifdef TAOS_MEM_CHECK_TEST

--- a/src/os/inc/osString.h
+++ b/src/os/inc/osString.h
@@ -39,7 +39,7 @@ extern "C" {
  do {                             \
    strncpy((dst), (src), (size)); \
    (dst)[(size)-1] = 0;           \
-  } while (0);
+  } while (0)
 #ifndef TAOS_OS_FUNC_STRING_STR2INT64
  int64_t tsosStr2int64(char *str);

--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -185,7 +185,7 @@ typedef struct SQueryRuntimeEnv {
  uint16_t             scanFlag;         // denotes reversed scan of data or not
  SFillInfo*           pFillInfo;
  SResultRowInfo       windowResInfo;
-  STSBuf*              pTSBuf;
+  STSBuf*              pTsBuf;
  STSCursor            cur;
  SQueryCostInfo       summary;
  void*                pQueryHandle;

--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -73,23 +73,27 @@ typedef struct SQuerySQL {
  SStrToken            selectToken;  // sql string
 } SQuerySQL;
+typedef struct SCreatedTableInfo {
+  SStrToken  name;        // table name token
+  SStrToken  stableName;  // super table name token , for using clause
+  SArray    *pTagVals;    // create by using super table, tag value
+  char      *fullname;    // table full name
+  STagData   tagdata;     // true tag data, super table full name is in STagData
+  int8_t     igExist;     // ignore if exists
+} SCreatedTableInfo;
 typedef struct SCreateTableSQL {
-  struct SStrToken name;  // meter name, create table [meterName] xxx
+  SStrToken    name;  // table name, create table [name] xxx
-  bool             existCheck;
+  int8_t       type;  // create normal table/from super table/ stream
+  bool         existCheck;
-  int8_t           type; // create normal table/from super table/ stream
  struct {
-    SArray        *pTagColumns; // SArray<TAOS_FIELD>
+    SArray    *pTagColumns; // SArray<TAOS_FIELD>
-    SArray        *pColumns;    // SArray<TAOS_FIELD>
+    SArray    *pColumns;    // SArray<TAOS_FIELD>
  } colInfo;
-  struct {
+  SArray      *childTableInfo;        // SArray<SCreatedTableInfo>
-    SStrToken      stableName;  // super table name, for using clause
+  SQuerySQL   *pSelect;
-    SArray        *pTagVals;    // create by using metric, tag value
-    STagData       tagdata;
-  } usingInfo;
-  SQuerySQL       *pSelect;
 } SCreateTableSQL;
 typedef struct SAlterTableSQL {
@@ -198,16 +202,16 @@ typedef struct tSQLExpr {
 } tSQLExpr;
 // used in select clause. select <tSQLExprList> from xxx
-typedef struct tSQLExprItem {
+typedef struct tSqlExprItem {
  tSQLExpr *pNode;      // The list of expressions
  char *    aliasName;  // alias name, null-terminated string
-} tSQLExprItem;
+} tSqlExprItem;
 // todo refactor by using SArray
 typedef struct tSQLExprList {
  int32_t       nExpr;  /* Number of expressions on the list */
  int32_t       nAlloc; /* Number of entries allocated below */
-  tSQLExprItem *a;      /* One entry for each expression */
+  tSqlExprItem *a;      /* One entry for each expression */
 } tSQLExprList;
 /**
@@ -229,62 +233,63 @@ SArray *tVariantListAppend(SArray *pList, tVariant *pVar, uint8_t sortOrder);
 SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
-tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optType);
+tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType);
-void tSQLExprDestroy(tSQLExpr *);
+void tSqlExprDestroy(tSQLExpr *pExpr);
-tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken);
+tSQLExprList *tSqlExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken);
-void tSQLExprListDestroy(tSQLExprList *pList);
+void tSqlExprListDestroy(tSQLExprList *pList);
-SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
+SQuerySQL *tSetQuerySqlElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
                             SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
-SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pMetricName,
+SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type);
-                                    SArray *pTagVals, SQuerySQL *pSelect, int32_t type);
-void tSQLExprNodeDestroy(tSQLExpr *pExpr);
+void tSqlExprNodeDestroy(tSQLExpr *pExpr);
-SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type);
+SAlterTableSQL *  tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type);
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 void destroyAllSelectClause(SSubclauseInfo *pSql);
 void doDestroyQuerySql(SQuerySQL *pSql);
+void freeCreateTableInfo(void* p);
-SSqlInfo *      setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type);
+SSqlInfo       *      setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
 SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
 SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
-void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists);
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
-void SQLInfoDestroy(SSqlInfo *pInfo);
+void SqlInfoDestroy(SSqlInfo *pInfo);
 void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
-void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck);
+void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck);
 void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns);
 tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SStrToken *pToken);
 void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDBInfo *pDB, SStrToken *pIgExists);
-void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo);
+void setCreateAcctSql(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo);
-void setCreateUserSQL(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd);
+void setCreateUserSql(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd);
-void setKillSQL(SSqlInfo *pInfo, int32_t type, SStrToken *ip);
+void setKillSql(SSqlInfo *pInfo, int32_t type, SStrToken *ip);
-void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege);
+void setAlterUserSql(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege);
 void setDefaultCreateDbOption(SCreateDBInfo *pDBInfo);
 // prefix show db.tables;
-void setDBName(SStrToken *pCpxName, SStrToken *pDB);
+void setDbName(SStrToken *pCpxName, SStrToken *pDb);
-tSQLExpr *tSQLExprIdValueCreate(SStrToken *pToken, int32_t optType);
+tSQLExpr *tSqlExprIdValueCreate(SStrToken *pToken, int32_t optrType);
-tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
+tSQLExpr *tSqlExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
-void tSQLSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
+void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
-void tSQLSetColumnType(TAOS_FIELD *pField, SStrToken *pToken);
+void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type);
 void *ParseAlloc(void *(*mallocProc)(size_t));

--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -24,36 +24,35 @@
 #define GET_RES_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t))
+#define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
+#define GET_ROW_PARAM_FOR_MULTIOUTPUT(_q, tbq, sq) (((tbq) && (!sq))? (_q)->pExpr1[1].base.arg->argValue.i64:1)
 int32_t getOutputInterResultBufSize(SQuery* pQuery);
-void clearResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pRow, int16_t type);
+size_t  getResultRowSize(SQueryRuntimeEnv* pRuntimeEnv);
-void copyResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* dst, const SResultRow* src, int16_t type);
+int32_t initResultRowInfo(SResultRowInfo* pResultRowInfo, int32_t size, int16_t type);
-SResultRowCellInfo* getResultCell(SQueryRuntimeEnv* pRuntimeEnv, const SResultRow* pRow, int32_t index);
+void    cleanupResultRowInfo(SResultRowInfo* pResultRowInfo);
-int32_t initWindowResInfo(SResultRowInfo* pWindowResInfo, int32_t size, int16_t type);
+void    resetResultRowInfo(SQueryRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo);
+void    popFrontResultRow(SQueryRuntimeEnv *pRuntimeEnv, SResultRowInfo *pResultRowInfo, int32_t num);
+void    clearClosedResultRows(SQueryRuntimeEnv* pRuntimeEnv, SResultRowInfo *pResultRowInfo);
+int32_t numOfClosedResultRows(SResultRowInfo* pResultRowInfo);
+void    closeAllResultRows(SResultRowInfo* pResultRowInfo);
+void    removeRedundantResultRows(SResultRowInfo *pResultRowInfo, TSKEY lastKey, int32_t order);
-void    cleanupTimeWindowInfo(SResultRowInfo* pWindowResInfo);
+int32_t initResultRow(SResultRow *pResultRow);
-void    resetTimeWindowInfo(SQueryRuntimeEnv* pRuntimeEnv, SResultRowInfo* pWindowResInfo);
+void    closeResultRow(SResultRowInfo* pResultRowInfo, int32_t slot);
-void    clearFirstNWindowRes(SQueryRuntimeEnv *pRuntimeEnv, int32_t num);
+bool    isResultRowClosed(SResultRowInfo *pResultRowInfo, int32_t slot);
+void    clearResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pResultRow, int16_t type);
+void    copyResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* dst, const SResultRow* src, int16_t type);
-void    clearClosedTimeWindow(SQueryRuntimeEnv* pRuntimeEnv);
+SResultRowCellInfo* getResultCell(SQueryRuntimeEnv* pRuntimeEnv, const SResultRow* pRow, int32_t index);
-int32_t numOfClosedTimeWindow(SResultRowInfo* pWindowResInfo);
-void    closeTimeWindow(SResultRowInfo* pWindowResInfo, int32_t slot);
-void    closeAllTimeWindow(SResultRowInfo* pWindowResInfo);
-void    removeRedundantWindow(SResultRowInfo *pWindowResInfo, TSKEY lastKey, int32_t order);
-static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pWindowResInfo, int32_t slot) {
+static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {
-  assert(pWindowResInfo != NULL && slot >= 0 && slot < pWindowResInfo->size);
+  assert(pResultRowInfo != NULL && slot >= 0 && slot < pResultRowInfo->size);
-  return pWindowResInfo->pResult[slot];
+  return pResultRowInfo->pResult[slot];
 }
-#define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
-#define GET_ROW_PARAM_FOR_MULTIOUTPUT(_q, tbq, sq) (((tbq) && (!sq))? (_q)->pExpr1[1].base.arg->argValue.i64:1)
-bool isWindowResClosed(SResultRowInfo *pWindowResInfo, int32_t slot);
-int32_t initResultRow(SResultRow *pResultRow);
 static FORCE_INLINE char *getPosInResultPage(SQueryRuntimeEnv *pRuntimeEnv, int32_t columnIndex, SResultRow *pResult,
    tFilePage* page) {
  assert(pResult != NULL && pRuntimeEnv != NULL);
@@ -71,8 +70,6 @@ bool notNull_filter(SColumnFilterElem *pFilter, char* minval, char* maxval);
 __filter_func_t *getRangeFilterFuncArray(int32_t type);
 __filter_func_t *getValueFilterFuncArray(int32_t type);
-size_t getWindowResultSize(SQueryRuntimeEnv* pRuntimeEnv);
 SResultRowPool* initResultRowPool(size_t size);
 SResultRow* getNewResultRow(SResultRowPool* p);
 int64_t getResultRowPoolMemSize(SResultRowPool* p);

--- a/src/query/inc/queryLog.h
+++ b/src/query/inc/queryLog.h
@@ -22,15 +22,15 @@ extern "C" {
 #include "tlog.h"
-extern int32_t qDebugFlag;
+extern uint32_t qDebugFlag;
-extern int32_t tscEmbedded;
+extern uint32_t tscEmbedded;
-#define qFatal(...) { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", 255, __VA_ARGS__); }}
+#define qFatal(...) do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", 255, __VA_ARGS__); }}  while(0)
-#define qError(...) { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", 255, __VA_ARGS__); }}
+#define qError(...) do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", 255, __VA_ARGS__); }}  while(0)
-#define qWarn(...)  { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", 255, __VA_ARGS__); }}
+#define qWarn(...)  do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", 255, __VA_ARGS__); }}   while(0)
-#define qInfo(...)  { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", 255, __VA_ARGS__); }}
+#define qInfo(...)  do { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", 255, __VA_ARGS__); }}        while(0)
-#define qDebug(...) { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }}
+#define qDebug(...) do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
-#define qTrace(...) { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }}
+#define qTrace(...) do { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
 #ifdef __cplusplus
 }

--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -168,12 +168,12 @@ ids(A) ::= ID(X).        {A = X; }
 ids(A) ::= STRING(X).    {A = X; }
 %type ifexists {SStrToken}
-ifexists(X) ::= IF EXISTS.          {X.n = 1;}
+ifexists(X) ::= IF EXISTS.          { X.n = 1;}
-ifexists(X) ::= .                   {X.n = 0;}
+ifexists(X) ::= .                   { X.n = 0;}
 %type ifnotexists {SStrToken}
-ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
+ifnotexists(X) ::= IF NOT EXISTS.   { X.n = 1;}
-ifnotexists(X) ::= .                {X.n = 0;}
+ifnotexists(X) ::= .                { X.n = 0;}
 /////////////////////////////////THE CREATE STATEMENT///////////////////////////////////////
 //create option for dnode/db/user/account
@@ -183,32 +183,32 @@ cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
 cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y).  { setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
 cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSQL(pInfo, &X, &Y);}
-pps(Y) ::= .                                {Y.n = 0;   }
+pps(Y) ::= .                                { Y.n = 0;   }
-pps(Y) ::= PPS INTEGER(X).                  {Y = X;     }
+pps(Y) ::= PPS INTEGER(X).                  { Y = X;     }
-tseries(Y) ::= .                            {Y.n = 0;   }
+tseries(Y) ::= .                            { Y.n = 0;   }
-tseries(Y) ::= TSERIES INTEGER(X).          {Y = X;     }
+tseries(Y) ::= TSERIES INTEGER(X).          { Y = X;     }
-dbs(Y) ::= .                                {Y.n = 0;   }
+dbs(Y) ::= .                                { Y.n = 0;   }
-dbs(Y) ::= DBS INTEGER(X).                  {Y = X;     }
+dbs(Y) ::= DBS INTEGER(X).                  { Y = X;     }
-streams(Y) ::= .                            {Y.n = 0;   }
+streams(Y) ::= .                            { Y.n = 0;   }
-streams(Y) ::= STREAMS INTEGER(X).          {Y = X;     }
+streams(Y) ::= STREAMS INTEGER(X).          { Y = X;     }
-storage(Y) ::= .                            {Y.n = 0;   }
+storage(Y) ::= .                            { Y.n = 0;   }
-storage(Y) ::= STORAGE INTEGER(X).          {Y = X;     }
+storage(Y) ::= STORAGE INTEGER(X).          { Y = X;     }
-qtime(Y) ::= .                              {Y.n = 0;   }
+qtime(Y) ::= .                              { Y.n = 0;   }
-qtime(Y) ::= QTIME INTEGER(X).              {Y = X;     }
+qtime(Y) ::= QTIME INTEGER(X).              { Y = X;     }
-users(Y) ::= .                              {Y.n = 0;   }
+users(Y) ::= .                              { Y.n = 0;   }
-users(Y) ::= USERS INTEGER(X).              {Y = X;     }
+users(Y) ::= USERS INTEGER(X).              { Y = X;     }
-conns(Y) ::= .                              {Y.n = 0;   }
+conns(Y) ::= .                              { Y.n = 0;   }
-conns(Y) ::= CONNS INTEGER(X).              {Y = X;     }
+conns(Y) ::= CONNS INTEGER(X).              { Y = X;     }
-state(Y) ::= .                              {Y.n = 0;   }
+state(Y) ::= .                              { Y.n = 0;   }
-state(Y) ::= STATE ids(X).                  {Y = X;     }
+state(Y) ::= STATE ids(X).                  { Y = X;     }
 %type acct_optr {SCreateAcctSQL}
 acct_optr(Y) ::= pps(C) tseries(D) storage(P) streams(F) qtime(Q) dbs(E) users(K) conns(L) state(M). {
@@ -269,7 +269,7 @@ alter_db_optr(Y) ::= alter_db_optr(Z) blocks(X).      { Y = Z; Y.numOfBlocks = s
 alter_db_optr(Y) ::= alter_db_optr(Z) comp(X).        { Y = Z; Y.compressionLevel = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) wal(X).         { Y = Z; Y.walLevel = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X).       { Y = Z; Y.fsyncPeriod = strtol(X.z, NULL, 10); }
-alter_db_optr(Y) ::= alter_db_optr(Z) update(X).       { Y = Z; Y.update = strtol(X.z, NULL, 10); }
+alter_db_optr(Y) ::= alter_db_optr(Z) update(X).      { Y = Z; Y.update = strtol(X.z, NULL, 10); }
 %type typename {TAOS_FIELD}
 typename(A) ::= ids(X). { 
@@ -279,13 +279,13 @@ typename(A) ::= ids(X). {
 //define binary type, e.g., binary(10), nchar(10)
 typename(A) ::= ids(X) LP signed(Y) RP.    {
-    if (Y <= 0) {
+  if (Y <= 0) {
-      X.type = 0;
+    X.type = 0;
-      tSQLSetColumnType(&A, &X);
+    tSQLSetColumnType(&A, &X);
-    } else {
+  } else {
-      X.type = -Y;          // negative value of name length
+    X.type = -Y;  // negative value of name length
-      tSQLSetColumnType(&A, &X);
+    tSQLSetColumnType(&A, &X);
-    }
+  }
 }
 %type signed {int64_t}
@@ -294,36 +294,60 @@ signed(A) ::= PLUS INTEGER(X).    { A = strtol(X.z, NULL, 10); }
 signed(A) ::= MINUS INTEGER(X).   { A = -strtol(X.z, NULL, 10);}
 ////////////////////////////////// The CREATE TABLE statement ///////////////////////////////
-cmd ::= CREATE TABLE ifnotexists(Y) ids(X) cpxName(Z) create_table_args.  {
+cmd ::= CREATE TABLE create_table_args. {}
-    X.n += Z.n;
+cmd ::= CREATE TABLE create_table_list(Z). { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = Z;}
-    setCreatedTableName(pInfo, &X, &Y);
+%type create_table_list{SCreateTableSQL*}
+%destructor create_table_list{destroyCreateTableSql($$);}
+create_table_list(A) ::= create_from_stable(Z). {
+  SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
+  pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
+  taosArrayPush(pCreateTable->childTableInfo, &Z);
+  pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
+  A = pCreateTable;
+}
+create_table_list(A) ::= create_table_list(X) create_from_stable(Z). {
+  taosArrayPush(X->childTableInfo, &Z);
+  A = X;
 }
 %type create_table_args{SCreateTableSQL*}
-create_table_args(A) ::= LP columnlist(X) RP. {
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
-    A = tSetCreateSQLElems(X, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
+  A = tSetCreateSQLElems(X, NULL, NULL, TSQL_CREATE_TABLE);
-    setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  V.n += Z.n;
+  setCreatedTableName(pInfo, &V, &U);
 }
 // create super table
-create_table_args(A) ::= LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
-    A = tSetCreateSQLElems(X, Y, NULL, NULL, NULL, TSQL_CREATE_STABLE);
+  A = tSetCreateSQLElems(X, Y, NULL, TSQL_CREATE_STABLE);
-    setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  V.n += Z.n;
+  setCreatedTableName(pInfo, &V, &U);
 }
 // create table by using super table
 // create table table_name using super_table_name tags(tag_values1, tag_values2)
-create_table_args(A) ::= USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP.  {
+%type create_from_stable{SCreatedTableInfo}
-    X.n += F.n;
+create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP.  {
-    A = tSetCreateSQLElems(NULL, NULL, &X, Y, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
+  X.n += F.n;
-    setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  V.n += Z.n;
+  A = createNewChildTableInfo(&X, Y, &V, &U);
 }
 // create stream
 // create table table_name as select count(*) from super_table_name interval(time)
-create_table_args(A) ::= AS select(S). {
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). {
-    A = tSetCreateSQLElems(NULL, NULL, NULL, NULL, S, TSQL_CREATE_STREAM);
+  A = tSetCreateSQLElems(NULL, NULL, S, TSQL_CREATE_STREAM);
-    setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  V.n += Z.n;
+  setCreatedTableName(pInfo, &V, &U);
 }
 %type column{TAOS_FIELD}
@@ -335,7 +359,7 @@ columnlist(A) ::= column(X).                      {A = taosArrayInit(4, sizeof(T
 // The information used for a column is the name and type of column:
 // tinyint smallint int bigint float double bool timestamp binary(x) nchar(x)
 column(A) ::= ids(X) typename(Y).          {
-    tSQLSetColumnInfo(&A, &X, &Y);
+  tSQLSetColumnInfo(&A, &X, &Y);
 }
 %type tagitemlist {SArray*}
@@ -345,10 +369,10 @@ column(A) ::= ids(X) typename(Y).          {
 tagitemlist(A) ::= tagitemlist(X) COMMA tagitem(Y). { A = tVariantListAppend(X, &Y, -1);    }
 tagitemlist(A) ::= tagitem(X).                      { A = tVariantListAppend(NULL, &X, -1); }
-tagitem(A) ::= INTEGER(X).      {toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= INTEGER(X).      { toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= FLOAT(X).        {toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= FLOAT(X).        { toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= STRING(X).       {toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= STRING(X).       { toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= BOOL(X).         {toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= BOOL(X).         { toTSDBType(X.type); tVariantCreate(&A, &X); }
 tagitem(A) ::= NULL(X).         { X.type = 0; tVariantCreate(&A, &X); }
 tagitem(A) ::= MINUS(X) INTEGER(Y).{
@@ -445,11 +469,11 @@ tablelist(A) ::= ids(X) cpxName(Y).                     {
 }
 tablelist(A) ::= ids(X) cpxName(Y) ids(Z).             {
-   toTSDBType(X.type);
+  toTSDBType(X.type);
-   toTSDBType(Z.type);
+  toTSDBType(Z.type);
-   X.n += Y.n;
+  X.n += Y.n;
-   A = tVariantListAppendToken(NULL, &X, -1);
+  A = tVariantListAppendToken(NULL, &X, -1);
-   A = tVariantListAppendToken(A, &Z, -1);
+  A = tVariantListAppendToken(A, &Z, -1);
 }
 tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z).  {
@@ -460,11 +484,11 @@ tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z).  {
 }
 tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z) ids(F). {
-   toTSDBType(X.type);
+  toTSDBType(X.type);
-   toTSDBType(F.type);
+  toTSDBType(F.type);
-   X.n += Z.n;
+  X.n += Z.n;
-   A = tVariantListAppendToken(Y, &X, -1);
+  A = tVariantListAppendToken(Y, &X, -1);
-   A = tVariantListAppendToken(A, &F, -1);
+  A = tVariantListAppendToken(A, &F, -1);
 }
 // The value of interval should be the form of "number+[a,s,m,h,d,n,y]" or "now"
@@ -526,9 +550,9 @@ item(A) ::= ids(X) cpxName(Y).   {
 }
 %type sortorder {int}
-sortorder(A) ::= ASC.           {A = TSDB_ORDER_ASC; }
+sortorder(A) ::= ASC.           { A = TSDB_ORDER_ASC; }
-sortorder(A) ::= DESC.          {A = TSDB_ORDER_DESC;}
+sortorder(A) ::= DESC.          { A = TSDB_ORDER_DESC;}
-sortorder(A) ::= .              {A = TSDB_ORDER_ASC;}  //default is descend order
+sortorder(A) ::= .              { A = TSDB_ORDER_ASC; }  // Ascending order by default
 //group by clause
 %type groupby_opt {SArray*}
@@ -536,8 +560,8 @@ sortorder(A) ::= .              {A = TSDB_ORDER_ASC;}  //default is descend orde
 %type grouplist {SArray*}
 %destructor grouplist {taosArrayDestroy($$);}
-groupby_opt(A) ::= .                       {A = 0;}
+groupby_opt(A) ::= .                       { A = 0;}
-groupby_opt(A) ::= GROUP BY grouplist(X).  {A = X;}
+groupby_opt(A) ::= GROUP BY grouplist(X).  { A = X;}
 grouplist(A) ::= grouplist(X) COMMA item(Y).    {
  A = tVariantListAppend(X, &Y, -1);
@@ -583,20 +607,20 @@ where_opt(A) ::= WHERE expr(X).       {A = X;}
 expr(A) ::= LP(X) expr(Y) RP(Z).       {A = Y; A->token.z = X.z; A->token.n = (Z.z - X.z + 1);}
-expr(A) ::= ID(X).               {A = tSQLExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X).               { A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT ID(Y).     {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X) DOT ID(Y).     { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT STAR(Y).   {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
+expr(A) ::= ID(X) DOT STAR(Y).   { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
-expr(A) ::= INTEGER(X).          {A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= INTEGER(X).          { A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= MINUS(X) INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= MINUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= PLUS(X)  INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= PLUS(X)  INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= FLOAT(X).            {A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= FLOAT(X).            { A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= MINUS(X) FLOAT(Y).   {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= MINUS(X) FLOAT(Y).   { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= PLUS(X) FLOAT(Y).    {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= PLUS(X) FLOAT(Y).    { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= STRING(X).           {A = tSQLExprIdValueCreate(&X, TK_STRING);}
+expr(A) ::= STRING(X).           { A = tSQLExprIdValueCreate(&X, TK_STRING);}
-expr(A) ::= NOW(X).              {A = tSQLExprIdValueCreate(&X, TK_NOW); }
+expr(A) ::= NOW(X).              { A = tSQLExprIdValueCreate(&X, TK_NOW); }
-expr(A) ::= VARIABLE(X).         {A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
+expr(A) ::= VARIABLE(X).         { A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
-expr(A) ::= BOOL(X).             {A = tSQLExprIdValueCreate(&X, TK_BOOL);}
+expr(A) ::= BOOL(X).             { A = tSQLExprIdValueCreate(&X, TK_BOOL);}
 // ordinary functions: min(x), max(x), top(k, 20)
 expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSQLExprCreateFunction(Y, &X, &E, X.type); }

--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -71,13 +71,13 @@ abort_parse:
  return sqlInfo;
 }
-tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken) {
+tSQLExprList *tSqlExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken) {
  if (pList == NULL) {
    pList = calloc(1, sizeof(tSQLExprList));
  }
  if (pList->nAlloc <= pList->nExpr) {
-    pList->nAlloc = (pList->nAlloc << 1) + 4;
+    pList->nAlloc = (pList->nAlloc << 1u) + 4;
    pList->a = realloc(pList->a, pList->nAlloc * sizeof(pList->a[0]));
    if (pList->a == 0) {
      pList->nExpr = pList->nAlloc = 0;
@@ -87,7 +87,7 @@ tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken
  assert(pList->a != 0);
  if (pNode || pToken) {
-    struct tSQLExprItem *pItem = &pList->a[pList->nExpr++];
+    struct tSqlExprItem *pItem = &pList->a[pList->nExpr++];
    memset(pItem, 0, sizeof(*pItem));
    pItem->pNode = pNode;
    if (pToken) {  // set the as clause
@@ -101,62 +101,62 @@ tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken
  return pList;
 }
-void tSQLExprListDestroy(tSQLExprList *pList) {
+void tSqlExprListDestroy(tSQLExprList *pList) {
  if (pList == NULL) return;
  for (int32_t i = 0; i < pList->nExpr; ++i) {
    if (pList->a[i].aliasName != NULL) {
      free(pList->a[i].aliasName);
    }
-    tSQLExprDestroy(pList->a[i].pNode);
+    tSqlExprDestroy(pList->a[i].pNode);
  }
  free(pList->a);
  free(pList);
 }
-tSQLExpr *tSQLExprIdValueCreate(SStrToken *pToken, int32_t optrType) {
+tSQLExpr *tSqlExprIdValueCreate(SStrToken *pToken, int32_t optrType) {
-  tSQLExpr *pSQLExpr = calloc(1, sizeof(tSQLExpr));
+  tSQLExpr *pSqlExpr = calloc(1, sizeof(tSQLExpr));
  if (pToken != NULL) {
-    pSQLExpr->token = *pToken;
+    pSqlExpr->token = *pToken;
  }
  if (optrType == TK_INTEGER || optrType == TK_STRING || optrType == TK_FLOAT || optrType == TK_BOOL) {
    toTSDBType(pToken->type);
-    tVariantCreate(&pSQLExpr->val, pToken);
+    tVariantCreate(&pSqlExpr->val, pToken);
-    pSQLExpr->nSQLOptr = optrType;
+    pSqlExpr->nSQLOptr = optrType;
  } else if (optrType == TK_NOW) {
    // use microsecond by default
-    pSQLExpr->val.i64Key = taosGetTimestamp(TSDB_TIME_PRECISION_MICRO);
+    pSqlExpr->val.i64Key = taosGetTimestamp(TSDB_TIME_PRECISION_MICRO);
-    pSQLExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
+    pSqlExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
-    pSQLExpr->nSQLOptr = TK_TIMESTAMP;  // TK_TIMESTAMP used to denote the time value is in microsecond
+    pSqlExpr->nSQLOptr = TK_TIMESTAMP;  // TK_TIMESTAMP used to denote the time value is in microsecond
  } else if (optrType == TK_VARIABLE) {
-    int32_t ret = parseAbsoluteDuration(pToken->z, pToken->n, &pSQLExpr->val.i64Key);
+    int32_t ret = parseAbsoluteDuration(pToken->z, pToken->n, &pSqlExpr->val.i64Key);
    if (ret != TSDB_CODE_SUCCESS) {
      terrno = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
    }
-    pSQLExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
+    pSqlExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
-    pSQLExpr->nSQLOptr = TK_TIMESTAMP;
+    pSqlExpr->nSQLOptr = TK_TIMESTAMP;
  } else {  // it must be the column name (tk_id) if it is not the number
    assert(optrType == TK_ID || optrType == TK_ALL);
    if (pToken != NULL) {
-      pSQLExpr->colInfo = *pToken;
+      pSqlExpr->colInfo = *pToken;
    }
-    pSQLExpr->nSQLOptr = optrType;
+    pSqlExpr->nSQLOptr = optrType;
  }
-  return pSQLExpr;
+  return pSqlExpr;
 }
 /*
 * pList is the parameters for function with id(optType)
 * function name is denoted by pFunctionToken
 */
-tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType) {
+tSQLExpr *tSqlExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType) {
  if (pFuncToken == NULL) return NULL;
  tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
@@ -177,7 +177,7 @@ tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SSt
 * create binary expression in this procedure
 * if the expr is arithmetic, calculate the result and set it to tSQLExpr Object
 */
-tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
+tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
  tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
  if (pLeft != NULL && pRight != NULL && (optrType != TK_IN)) {
@@ -223,8 +223,8 @@ tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
        }
      }
-      tSQLExprDestroy(pLeft);
+      tSqlExprDestroy(pLeft);
-      tSQLExprDestroy(pRight);
+      tSqlExprDestroy(pRight);
    } else if ((pLeft->nSQLOptr == TK_FLOAT && pRight->nSQLOptr == TK_INTEGER) || (pLeft->nSQLOptr == TK_INTEGER && pRight->nSQLOptr == TK_FLOAT) ||
        (pLeft->nSQLOptr == TK_FLOAT && pRight->nSQLOptr == TK_FLOAT)) {
@@ -257,8 +257,8 @@ tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
        }
      }
-      tSQLExprDestroy(pLeft);
+      tSqlExprDestroy(pLeft);
-      tSQLExprDestroy(pRight);
+      tSqlExprDestroy(pRight);
    } else {
      pExpr->nSQLOptr = optrType;
@@ -288,7 +288,7 @@ tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
  return pExpr;
 }
-void tSQLExprNodeDestroy(tSQLExpr *pExpr) {
+void tSqlExprNodeDestroy(tSQLExpr *pExpr) {
  if (pExpr == NULL) {
    return;
  }
@@ -297,20 +297,20 @@ void tSQLExprNodeDestroy(tSQLExpr *pExpr) {
    tVariantDestroy(&pExpr->val);
  }
-  tSQLExprListDestroy(pExpr->pParam);
+  tSqlExprListDestroy(pExpr->pParam);
  free(pExpr);
 }
-void tSQLExprDestroy(tSQLExpr *pExpr) {
+void tSqlExprDestroy(tSQLExpr *pExpr) {
  if (pExpr == NULL) {
    return;
  }
-  tSQLExprDestroy(pExpr->pLeft);
+  tSqlExprDestroy(pExpr->pLeft);
-  tSQLExprDestroy(pExpr->pRight);
+  tSqlExprDestroy(pExpr->pRight);
-  tSQLExprNodeDestroy(pExpr);
+  tSqlExprNodeDestroy(pExpr);
 }
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pToken, uint8_t order) {
@@ -366,13 +366,13 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
  return pList;
 }
-void setDBName(SStrToken *pCpxName, SStrToken *pDB) {
+void setDbName(SStrToken *pCpxName, SStrToken *pDb) {
-  pCpxName->type = pDB->type;
+  pCpxName->type = pDb->type;
-  pCpxName->z = pDB->z;
+  pCpxName->z = pDb->z;
-  pCpxName->n = pDB->n;
+  pCpxName->n = pDb->n;
 }
-void tSQLSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType) {
+void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType) {
  int32_t maxLen = sizeof(pField->name) / sizeof(pField->name[0]);
  // truncate the column name
@@ -387,10 +387,10 @@ void tSQLSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType)
  pField->bytes = pType->bytes;
 }
-void tSQLSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
+void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
  pField->type = -1;
-  for (int8_t i = 0; i < tListLen(tDataTypeDesc); ++i) {
+  for (int32_t i = 0; i < tListLen(tDataTypeDesc); ++i) {
    if ((strncasecmp(type->z, tDataTypeDesc[i].aName, tDataTypeDesc[i].nameLen) == 0) &&
        (type->n == tDataTypeDesc[i].nameLen)) {
      pField->type = i;
@@ -438,7 +438,7 @@ void tSQLSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
 /*
 * extract the select info out of sql string
 */
-SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
+SQuerySQL *tSetQuerySqlElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
                             SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit) {
  assert(pSelection != NULL);
@@ -474,21 +474,28 @@ SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
  return pQuery;
 }
-void freeVariant(void *pItem) {
+static void freeVariant(void *pItem) {
  tVariantListItem* p = (tVariantListItem*) pItem;
  tVariantDestroy(&p->pVar);
 }
+void freeCreateTableInfo(void* p) {
+  SCreatedTableInfo* pInfo = (SCreatedTableInfo*) p;
+  taosArrayDestroyEx(pInfo->pTagVals, freeVariant);
+  tfree(pInfo->fullname);
+  tfree(pInfo->tagdata.data);
+}
 void doDestroyQuerySql(SQuerySQL *pQuerySql) {
  if (pQuerySql == NULL) {
    return;
  }
-  tSQLExprListDestroy(pQuerySql->pSelection);
+  tSqlExprListDestroy(pQuerySql->pSelection);
  pQuerySql->pSelection = NULL;
-  tSQLExprDestroy(pQuerySql->pWhere);
+  tSqlExprDestroy(pQuerySql->pWhere);
  pQuerySql->pWhere = NULL;
  taosArrayDestroyEx(pQuerySql->pSortOrder, freeVariant);
@@ -519,31 +526,30 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
  tfree(pClause->pClause);
 }
-SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pStableName,
+SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type) {
-                                    SArray *pTagVals, SQuerySQL *pSelect, int32_t type) {
  SCreateTableSQL *pCreate = calloc(1, sizeof(SCreateTableSQL));
  switch (type) {
    case TSQL_CREATE_TABLE: {
      pCreate->colInfo.pColumns = pCols;
-      assert(pTagVals == NULL && pTags == NULL);
+      assert(pTags == NULL);
      break;
    }
    case TSQL_CREATE_STABLE: {
      pCreate->colInfo.pColumns = pCols;
      pCreate->colInfo.pTagColumns = pTags;
-      assert(pTagVals == NULL && pTags != NULL && pCols != NULL);
+      assert(pTags != NULL && pCols != NULL);
-      break;
-    }
-    case TSQL_CREATE_TABLE_FROM_STABLE: {
-      pCreate->usingInfo.pTagVals = pTagVals;
-      pCreate->usingInfo.stableName = *pStableName;
      break;
    }
    case TSQL_CREATE_STREAM: {
      pCreate->pSelect = pSelect;
      break;
    }
+    case TSQL_CREATE_TABLE_FROM_STABLE: {
+      assert(0);
+    }
    default:
      assert(false);
  }
@@ -552,10 +558,22 @@ SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pSt
  return pCreate;
 }
-SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type) {
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists) {
+  SCreatedTableInfo info;
+  memset(&info, 0, sizeof(SCreatedTableInfo));
+  info.name       = *pToken;
+  info.pTagVals   = pTagVals;
+  info.stableName = *pTableName;
+  info.igExist    = (igExists->n > 0)? 1:0;
+  return info;
+}
+SAlterTableSQL *tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type) {
  SAlterTableSQL *pAlterTable = calloc(1, sizeof(SAlterTableSQL));
-  pAlterTable->name = *pMeterName;
+  pAlterTable->name = *pTableName;
  pAlterTable->type = type;
  if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
@@ -573,24 +591,29 @@ SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray
  return pAlterTable;
 }
-void SQLInfoDestroy(SSqlInfo *pInfo) {
+void* destroyCreateTableSql(SCreateTableSQL* pCreate) {
+  doDestroyQuerySql(pCreate->pSelect);
+  taosArrayDestroy(pCreate->colInfo.pColumns);
+  taosArrayDestroy(pCreate->colInfo.pTagColumns);
+  taosArrayDestroyEx(pCreate->childTableInfo, freeCreateTableInfo);
+  tfree(pCreate);
+  return NULL;
+}
+void SqlInfoDestroy(SSqlInfo *pInfo) {
  if (pInfo == NULL) return;
  if (pInfo->type == TSDB_SQL_SELECT) {
    destroyAllSelectClause(&pInfo->subclauseInfo);
  } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
-    SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
+    pInfo->pCreateTableInfo = destroyCreateTableSql(pInfo->pCreateTableInfo);
-    doDestroyQuerySql(pCreateTableInfo->pSelect);
-    taosArrayDestroy(pCreateTableInfo->colInfo.pColumns);
-    taosArrayDestroy(pCreateTableInfo->colInfo.pTagColumns);
-    taosArrayDestroyEx(pCreateTableInfo->usingInfo.pTagVals, freeVariant);
-    tfree(pInfo->pCreateTableInfo);
  } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
    taosArrayDestroyEx(pInfo->pAlterInfo->varList, freeVariant);
    taosArrayDestroy(pInfo->pAlterInfo->pAddColumns);
+    tfree(pInfo->pAlterInfo->tagData.data);
    tfree(pInfo->pAlterInfo);
  } else {
    if (pInfo->pDCLInfo != NULL && pInfo->pDCLInfo->nAlloc > 0) {
@@ -624,7 +647,7 @@ SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
  return pSubclause;
 }
-SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type) {
+SSqlInfo*setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type) {
  pInfo->type = type;
  if (type == TSDB_SQL_SELECT) {
@@ -634,8 +657,8 @@ SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName,
    pInfo->pCreateTableInfo = pSqlExprInfo;
  }
-  if (pMeterName != NULL) {
+  if (pTableName != NULL) {
-    pInfo->pCreateTableInfo->name = *pMeterName;
+    pInfo->pCreateTableInfo->name = *pTableName;
  }
  return pInfo;
@@ -653,14 +676,14 @@ SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause)
  return pQueryInfo;
 }
-void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists) {
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists) {
-  pInfo->pCreateTableInfo->name = *pMeterName;
+  pInfo->pCreateTableInfo->name = *pTableNameToken;
  pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
 void tTokenListBuyMoreSpace(tDCLSQL *pTokenList) {
  if (pTokenList->nAlloc <= pTokenList->nTokens) {  //
-    pTokenList->nAlloc = (pTokenList->nAlloc << 1) + 4;
+    pTokenList->nAlloc = (pTokenList->nAlloc << 1u) + 4;
    pTokenList->a = realloc(pTokenList->a, pTokenList->nAlloc * sizeof(pTokenList->a[0]));
    if (pTokenList->a == 0) {
      pTokenList->nTokens = pTokenList->nAlloc = 0;
@@ -695,7 +718,7 @@ void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
  va_end(va);
 }
-void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck) {
+void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck) {
  pInfo->type = type;
  pInfo->pDCLInfo = tTokenListAppend(pInfo->pDCLInfo, pToken);
  pInfo->pDCLInfo->existsCheck = (existsCheck->n == 1);
@@ -735,7 +758,7 @@ void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDBI
  pInfo->pDCLInfo->dbOpt.ignoreExists = pIgExists->n; // sql.y has: ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
 }
-void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo) {
+void setCreateAcctSql(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo) {
  pInfo->type = type;
  if (pInfo->pDCLInfo == NULL) {
    pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -751,7 +774,7 @@ void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken
  }
 }
-void setCreateUserSQL(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd) {
+void setCreateUserSql(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd) {
  pInfo->type = TSDB_SQL_CREATE_USER;
  if (pInfo->pDCLInfo == NULL) {
    pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -763,7 +786,7 @@ void setCreateUserSQL(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd) {
  pInfo->pDCLInfo->user.passwd = *pPasswd;
 }
-void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege) {
+void setAlterUserSql(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege) {
  pInfo->type = TSDB_SQL_ALTER_USER;
  if (pInfo->pDCLInfo == NULL) {
    pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -788,7 +811,7 @@ void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken*
  }
 }
-void setKillSQL(SSqlInfo *pInfo, int32_t type, SStrToken *ip) {
+void setKillSql(SSqlInfo *pInfo, int32_t type, SStrToken *ip) {
  pInfo->type = type;
  if (pInfo->pDCLInfo == NULL) {
    pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));

--- 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
@@ -23,7 +23,7 @@ extern "C" {
 #include "tlog.h"
 extern int32_t rpcDebugFlag;
-extern int32_t tscEmbedded;
+extern uint32_t tscEmbedded;
 #define tFatal(...) { if (rpcDebugFlag & DEBUG_FATAL) { taosPrintLog("RPC FATAL ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
 #define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("RPC ERROR ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}

--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -313,7 +313,7 @@ void *rpcOpen(const SRpcInit *pInit) {
    return NULL;
  }
-  tDebug("%s rpc is openned, threads:%d sessions:%d", pRpc->label, pRpc->numOfThreads, pInit->sessions);
+  tDebug("%s rpc is opened, threads:%d sessions:%d", pRpc->label, pRpc->numOfThreads, pInit->sessions);
  return pRpc;
 }

--- a/src/sync/CMakeLists.txt
+++ b/src/sync/CMakeLists.txt
@@ -5,12 +5,12 @@ INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 IF (TD_LINUX)
-  LIST(REMOVE_ITEM SRC src/tarbitrator.c)
+  LIST(REMOVE_ITEM SRC src/syncArbitrator.c)
  ADD_LIBRARY(sync ${SRC})
  TARGET_LINK_LIBRARIES(sync tutil pthread common)
-  LIST(APPEND BIN_SRC src/tarbitrator.c)
+  LIST(APPEND BIN_SRC src/syncArbitrator.c)
-  LIST(APPEND BIN_SRC src/taosTcpPool.c)
+  LIST(APPEND BIN_SRC src/syncTcp.c)
  ADD_EXECUTABLE(tarbitrator ${BIN_SRC})
  TARGET_LINK_LIBRARIES(tarbitrator sync common osdetail tutil)

--- 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
@@ -13,16 +13,13 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef TDENGINE_TCP_POOL_H
+#ifndef TDENGINE_SYNC_TCP_POOL_H
-#define TDENGINE_TCP_POOL_H
+#define TDENGINE_SYNC_TCP_POOL_H
 #ifdef __cplusplus
 extern "C" {
 #endif
-typedef void *ttpool_h;
-typedef void *tthread_h;
 typedef struct {
  int32_t   numOfThreads;
  uint32_t  serverIp;
@@ -33,10 +30,10 @@ typedef struct {
  void    (*processIncomingConn)(int32_t fd, uint32_t ip);
 } SPoolInfo;
-ttpool_h taosOpenTcpThreadPool(SPoolInfo *pInfo);
+void *syncOpenTcpThreadPool(SPoolInfo *pInfo);
-void     taosCloseTcpThreadPool(ttpool_h);
+void  syncCloseTcpThreadPool(void *);
-void *   taosAllocateTcpConn(void *, void *ahandle, int32_t connFd);
+void *syncAllocateTcpConn(void *, void *ahandle, int32_t connFd);
-void     taosFreeTcpConn(void *);
+void  syncFreeTcpConn(void *);
 #ifdef __cplusplus
 }

--- 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
@@ -56,7 +56,7 @@ static int32_t syncRestoreFile(SSyncPeer *pPeer, uint64_t *fversion) {
  SSyncNode *pNode = pPeer->pSyncNode;
  SFileInfo  minfo; memset(&minfo, 0, sizeof(SFileInfo)); /* = {0}; */
  SFileInfo  sinfo; memset(&sinfo, 0, sizeof(SFileInfo)); /* = {0}; */
-  SFileAck   fileAck = {0};
+  SFileAck   fileAck; memset(&fileAck, 0, sizeof(SFileAck));
  int32_t    code = -1;
  char       name[TSDB_FILENAME_LEN * 2] = {0};
  uint32_t   pindex = 0;  // index in last restore
@@ -69,7 +69,14 @@ static int32_t syncRestoreFile(SSyncPeer *pPeer, uint64_t *fversion) {
    minfo.index = -1;
    int32_t ret = taosReadMsg(pPeer->syncFd, &minfo, sizeof(SFileInfo));
    if (ret != sizeof(SFileInfo) || minfo.index == -1) {
-      sError("%s, failed to read file info while restore file since %s", pPeer->id, strerror(errno));
+      sError("%s, failed to read fileinfo while restore file since %s", pPeer->id, strerror(errno));
+      break;
+    }
+    assert(ret == sizeof(SFileInfo));
+    ret = syncCheckHead((SSyncHead *)(&minfo));
+    if (ret != 0) {
+      sError("%s, failed to check fileinfo while restore file since %s", pPeer->id, strerror(ret));
      break;
    }
@@ -94,12 +101,13 @@ static int32_t syncRestoreFile(SSyncPeer *pPeer, uint64_t *fversion) {
                                        &sinfo.fversion);
    // if file not there or magic is not the same, file shall be synced
-    memset(&fileAck, 0, sizeof(fileAck));
+    memset(&fileAck, 0, sizeof(SFileAck));
+    syncBuildFileAck(&fileAck, pNode->vgId);
    fileAck.sync = (sinfo.magic != minfo.magic || sinfo.name[0] == 0) ? 1 : 0;
    // send file ack
-    ret = taosWriteMsg(pPeer->syncFd, &fileAck, sizeof(fileAck));
+    ret = taosWriteMsg(pPeer->syncFd, &fileAck, sizeof(SFileAck));
-    if (ret != sizeof(fileAck)) {
+    if (ret != sizeof(SFileAck)) {
      sError("%s, failed to write file:%s ack while restore file since %s", pPeer->id, minfo.name, strerror(errno));
      break;
    }
@@ -289,12 +297,12 @@ static int32_t syncRestoreDataStepByStep(SSyncPeer *pPeer) {
  uint64_t fversion = 0;
  sInfo("%s, start to restore, sstatus:%s", pPeer->id, syncStatus[pPeer->sstatus]);
-  SFirstPktRsp firstPktRsp = {.sync = 1, .tranId = syncGenTranId()};
+  SSyncRsp rsp = {.sync = 1, .tranId = syncGenTranId()};
-  if (taosWriteMsg(pPeer->syncFd, &firstPktRsp, sizeof(SFirstPktRsp)) != sizeof(SFirstPktRsp)) {
+  if (taosWriteMsg(pPeer->syncFd, &rsp, sizeof(SSyncRsp)) != sizeof(SSyncRsp)) {
-    sError("%s, failed to send sync firstPkt rsp since %s", pPeer->id, strerror(errno));
+    sError("%s, failed to send sync rsp since %s", pPeer->id, strerror(errno));
    return -1;
  }
-  sDebug("%s, send firstPktRsp to peer, tranId:%u", pPeer->id, firstPktRsp.tranId);
+  sDebug("%s, send sync rsp to peer, tranId:%u", pPeer->id, rsp.tranId);
  sInfo("%s, start to restore file, set sstatus:%s", pPeer->id, syncStatus[nodeSStatus]);
  int32_t code = syncRestoreFile(pPeer, &fversion);

--- 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/util/inc/tstoken.h
+++ b/src/util/inc/tstoken.h
--- 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/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/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/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/queryError.py
+++ b/tests/pytest/query/queryError.py
--- a/tests/pytest/query/queryNullValueTest.py
+++ b/tests/pytest/query/queryNullValueTest.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/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.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/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