Merge branch 'develop' into feature/szhou/tagregex

85ddd76d · shenglian zhou · f8fdc010 · 5bba39ad · 85ddd76d · 85ddd76d
147 changed file
--- a/.drone.yml
+++ b/.drone.yml
@@ -23,6 +23,7 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
 ---
 kind: pipeline
 name: test_arm64_bionic
@@ -150,6 +151,7 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
 ---
 kind: pipeline
 name: build_trusty
@@ -176,6 +178,7 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
 ---
 kind: pipeline
 name: build_xenial
@@ -201,7 +204,7 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
 ---
 kind: pipeline
 name: build_bionic
@@ -226,6 +229,7 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
 ---
 kind: pipeline
 name: build_centos7
@@ -249,4 +253,4 @@ steps:
    branch:
    - develop
    - master
+    - 2.0
\ No newline at end of file
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -265,12 +265,12 @@ pipeline {
                }
            }
            timeout(time: 60, unit: 'MINUTES'){
-              sh '''
+              // sh '''
-              cd ${WKC}/tests/pytest
+              // cd ${WKC}/tests/pytest
-              rm -rf /var/lib/taos/*
+              // rm -rf /var/lib/taos/*
-              rm -rf /var/log/taos/*
+              // rm -rf /var/log/taos/*
-              ./handle_crash_gen_val_log.sh
+              // ./handle_crash_gen_val_log.sh
-              '''
+              // '''
              sh '''
              cd ${WKC}/tests/pytest
              rm -rf /var/lib/taos/*

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

--- a/deps/MsvcLibX/src/iconv.c
+++ b/deps/MsvcLibX/src/iconv.c
@@ -98,6 +98,7 @@ int ConvertString(char *buf, size_t nBytes, UINT cpFrom, UINT cpTo, LPCSTR lpDef
 char *DupAndConvert(const char *string, UINT cpFrom, UINT cpTo, LPCSTR lpDefaultChar) {
  int nBytes;
  char *pBuf;
+  char *pBuf1;
  nBytes = 4 * ((int)lstrlen(string) + 1); /* Worst case for the size needed */
  pBuf = (char *)malloc(nBytes);
  if (!pBuf) {
@@ -110,8 +111,9 @@ char *DupAndConvert(const char *string, UINT cpFrom, UINT cpTo, LPCSTR lpDefault
    free(pBuf);
    return NULL;
  }
-  pBuf = realloc(pBuf, nBytes+1);
+  pBuf1 = realloc(pBuf, nBytes+1);
-  return pBuf;
+  if(pBuf1 == NULL && pBuf != NULL)  free(pBuf);
+  return pBuf1;
 }
 int CountCharacters(const char *string, UINT cp) {

--- a/deps/MsvcLibX/src/main.c
+++ b/deps/MsvcLibX/src/main.c
@@ -68,6 +68,7 @@ int BreakArgLine(LPSTR pszCmdLine, char ***pppszArg) {
  int iString = FALSE;	/* TRUE = string mode; FALSE = non-string mode */
  int nBackslash = 0;
  char **ppszArg;
+  char **ppszArg1;
  int iArg = FALSE;	/* TRUE = inside an argument; FALSE = between arguments */
  ppszArg = (char **)malloc((argc+1)*sizeof(char *));
@@ -89,7 +90,10 @@ int BreakArgLine(LPSTR pszCmdLine, char ***pppszArg) {
    if ((!iArg) && (c != ' ') && (c != '\t')) { /* Beginning of a new argument */
      iArg = TRUE;
      ppszArg[argc++] = pszCopy+j;
-      ppszArg = (char **)realloc(ppszArg, (argc+1)*sizeof(char *));
+      ppszArg1 = (char **)realloc(ppszArg, (argc+1)*sizeof(char *));
+      if(ppszArg1 == NULL && ppszArg != NULL)
+            free(ppszArg); 
+      ppszArg = ppszArg1;
      if (!ppszArg) return -1;
      pszCopy[j] = c0 = '\0';
    }
@@ -212,7 +216,7 @@ int _initU(void) {
    fprintf(stderr, "Warning: Can't convert the argument line to UTF-8\n");
    _acmdln[0] = '\0';
  }
-  realloc(_acmdln, n+1); /* Resize the memory block to fit the UTF-8 line */
+  //realloc(_acmdln, n+1); /* Resize the memory block to fit the UTF-8 line */
  /* Should not fail since we make it smaller */
  /* Record the console code page, to allow converting the output accordingly */

--- a/deps/MsvcLibX/src/realpath.c
+++ b/deps/MsvcLibX/src/realpath.c
@@ -196,6 +196,7 @@ not_compact_enough:
 /* Normally defined in stdlib.h. Output buf must contain PATH_MAX bytes */
 char *realpath(const char *path, char *outbuf) {
  char *pOutbuf = outbuf;
+  char *pOutbuf1 = NULL;
  int iErr;
  const char *pc;
@@ -242,8 +243,11 @@ realpath_failed:
    return NULL;
  }
-  if (!outbuf) pOutbuf = realloc(pOutbuf, strlen(pOutbuf) + 1);
+  if (!outbuf) {
-  return pOutbuf;
+    pOutbuf1 = realloc(pOutbuf, strlen(pOutbuf) + 1);
+    if(pOutbuf1 == NULL && pOutbuf) free(pOutbuf);
+  }
+  return pOutbuf1;
 }
 #endif
@@ -517,6 +521,7 @@ int ResolveLinksA(const char *path, char *buf, size_t bufsize) {
 /* Normally defined in stdlib.h. Output buf must contain PATH_MAX bytes */
 char *realpathU(const char *path, char *outbuf) {
  char *pOutbuf = outbuf;
+  char *pOutbuf1 = NULL;
  char *pPath1 = NULL;
  char *pPath2 = NULL;
  int iErr;
@@ -590,10 +595,13 @@ realpathU_failed:
  }
  DEBUG_LEAVE(("return 0x%p; // \"%s\"\n", pOutbuf, pOutbuf));
-  if (!outbuf) pOutbuf = realloc(pOutbuf, strlen(pOutbuf) + 1);
+  if (!outbuf) {
+    pOutbuf1 = realloc(pOutbuf, strlen(pOutbuf) + 1);
+    if(pOutbuf1 == NULL && pOutbuf) free(pOutbuf);
+  }  
  free(pPath1);
  free(pPath2);
-  return pOutbuf;
+  return pOutbuf1;
 }
 #endif /* defined(_WIN32) */

--- a/documentation20/cn/01.evaluation/docs.md
+++ b/documentation20/cn/01.evaluation/docs.md
@@ -2,18 +2,18 @@
 ## <a class="anchor" id="intro"></a>TDengine 简介
-TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
+TDengine 是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL 数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
-TDengine的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与Hadoop等典型的大数据平台相比，它具有如下鲜明的特点：
+TDengine 的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine 还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与 Hadoop 等典型的大数据平台相比，它具有如下鲜明的特点：
-* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
+* __10 倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少 2 万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
-* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
+* __硬件或云服务成本降至 1/5__：由于超强性能，计算资源不到通用大数据方案的 1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的 1/10。
-* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
+* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成 Kafka/Redis/HBase/Spark/HDFS 等软件，大幅降低应用开发和维护的复杂度成本。 
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, MATLAB随时进行。
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过 Shell, Python, R, MATLAB 随时进行。
-* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R等集成。后续将支持OPC, Hadoop, Spark等，BI工具也将无缝连接。
+* __与第三方工具无缝连接__：不用一行代码，即可与 Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R 等集成。后续将支持 OPC, Hadoop, Spark 等，BI 工具也将无缝连接。
-* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类标准SQL，支持RESTful，支持Python/Java/C/C++/C#/Go/Node.js, 与MySQL相似，零学习成本。
+* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类标准 SQL，支持 RESTful，支持 Python/Java/C/C++/C#/Go/Node.js, 与 MySQL 相似，零学习成本。
-采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
+采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。
 ![TDengine技术生态图](page://images/eco_system.png)
 <center>图 1. TDengine技术生态图</center>
@@ -21,42 +21,47 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 ## <a class="anchor" id="scenes"></a>TDengine 总体适用场景
-作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
+作为一个 IoT 大数据平台，TDengine 的典型适用场景是在 IoT 范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如 CRM，ERP 等，不在本文讨论范围内。
 ### 数据源特点和需求
-从数据源角度，设计人员可以从下面几个角度分析TDengine在目标应用系统里面的适用性。
+从数据源角度，设计人员可以从下面几个角度分析 TDengine 在目标应用系统里面的适用性。
 |数据源特点和需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|总体数据量巨大|  |  | √ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
+|总体数据量巨大|  |  | √ | TDengine 在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
-|数据输入速度偶尔或者持续巨大|   |   | √ | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
+|数据输入速度偶尔或者持续巨大|   |   | √ | TDengine 的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
-|数据源数目巨大|   |   | √ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
+|数据源数目巨大|   |   | √ | TDengine 设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
 ### 系统架构要求
 |系统架构要求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求简单可靠的系统架构|  |  | √ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
+|要求简单可靠的系统架构|  |  | √ | TDengine 的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
-|要求容错和高可靠|  |  | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能。|
+|要求容错和高可靠|  |  | √ | TDengine 的集群功能，自动提供容错灾备等高可靠功能。|
-|标准化规范|  |  | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范。|
+|标准化规范|  |  | √ | TDengine 使用标准的 SQL 语言提供主要功能，遵守标准化规范。|
 ### 系统功能需求
 |系统功能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求完整的内置数据处理算法|  | √ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
+|要求完整的内置数据处理算法|  | √ |  | TDengine 的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
-|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能。|
+|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑 TDengine 和关系型数据系统配合实现系统功能。|
 ### 系统性能需求
 |系统性能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求较大的总体处理能力|  |  | √ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
+|要求较大的总体处理能力|  |  | √ | TDengine 的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
-|要求高速处理数据  | | | √ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
+|要求高速处理数据  | | | √ | TDengine 的专门为 IoT 优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
-|要求快速处理小粒度数据|  |  | √ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
+|要求快速处理小粒度数据|  |  | √ |这方面 TDengine 性能可以完全对标关系型和 NoSQL 型数据处理系统。|
 ### 系统维护需求
 |系统维护需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求系统可靠运行|  |  | √ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
+|要求系统可靠运行|  |  | √ | TDengine 的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
 |要求运维学习成本可控|  |  | √ |同上。|
-|要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
+|要求市场有大量人才储备| √ |  |  | TDengine 作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
--- a/documentation20/cn/02.getting-started/01.docker/docs.md
+++ b/documentation20/cn/02.getting-started/01.docker/docs.md
 # 通过 Docker 快速体验 TDengine
-虽然并不推荐在生产环境中通过 Docker 来部署 TDengine 服务，但 Docker 工具能够很好地屏蔽底层操作系统的环境差异，很适合在开发测试或初次体验时用于安装运行 TDengine 的工具集。特别是，借助 Docker，能够比较方便地在 Mac OSX 和 Windows 系统上尝试 TDengine，而无需安装虚拟机或额外租用 Linux 服务器。
+虽然并不推荐在生产环境中通过 Docker 来部署 TDengine 服务，但 Docker 工具能够很好地屏蔽底层操作系统的环境差异，很适合在开发测试或初次体验时用于安装运行 TDengine 的工具集。特别是，借助 Docker，能够比较方便地在 Mac OSX 和 Windows 系统上尝试 TDengine，而无需安装虚拟机或额外租用 Linux 服务器。另外，从2.0.14.0版本开始，TDengine提供的镜像已经可以同时支持X86-64、X86、arm64、arm32平台，像NAS、树莓派、嵌入式开发板之类可以运行docker的非主流计算机也可以基于本文档轻松体验TDengine。
 下文通过 Step by Step 风格的介绍，讲解如何通过 Docker 快速建立 TDengine 的单节点运行环境，以支持开发和测试。
@@ -12,7 +12,7 @@ Docker 工具自身的下载请参考 [Docker官网文档](https://docs.docker.c
 ```bash
 $ docker -v
-Docker version 20.10.5, build 55c4c88
+Docker version 20.10.3, build 48d30b5
 ```
 ## 在 Docker 容器中运行 TDengine
@@ -20,21 +20,22 @@ Docker version 20.10.5, build 55c4c88
 1，使用命令拉取 TDengine 镜像，并使它在后台运行。
 ```bash
-$ docker run -d tdengine/tdengine
+$  docker run -d --name tdengine tdengine/tdengine
-cdf548465318c6fc2ad97813f89cc60006393392401cae58a27b15ca9171f316
+7760c955f225d72e9c1ec5a4cef66149a7b94dae7598b11eb392138877e7d292
 ```
- **docker run**：通过 Docker 运行一个容器。
+- **docker run**：通过 Docker 运行一个容器
- **-d**：让容器在后台运行。
+- **--name tdengine**：设置容器名称，我们可以通过容器名称来查看对应的容器
- **tdengine/tdengine**：拉取的 TDengine 官方发布的应用镜像。
+- **-d**：让容器在后台运行
- **cdf548465318c6fc2ad97813f89cc60006393392401cae58a27b15ca9171f316**：这个返回的长字符是容器 ID，我们可以通过容器 ID 来查看对应的容器。
+- **tdengine/tdengine**：拉取的 TDengine 官方发布的应用镜像
+- **7760c955f225d72e9c1ec5a4cef66149a7b94dae7598b11eb392138877e7d292**：这个返回的长字符是容器 ID，我们也可以通过容器 ID 来查看对应的容器
 2，确认容器是否已经正确运行。
 ```bash
 $ docker ps
 CONTAINER ID   IMAGE               COMMAND   CREATED          STATUS          ···
-cdf548465318   tdengine/tdengine   "taosd"   14 minutes ago   Up 14 minutes   ···
+c452519b0f9b   tdengine/tdengine   "taosd"   14 minutes ago   Up 14 minutes   ···
 ```
 - **docker ps**：列出所有正在运行状态的容器信息。
@@ -47,22 +48,22 @@ cdf548465318   tdengine/tdengine   "taosd"   14 minutes ago   Up 14 minutes   ·
 3，进入 Docker 容器内，使用 TDengine。
 ```bash
-$ docker exec -it cdf548465318 /bin/bash
+$ docker exec -it tdengine /bin/bash
-root@cdf548465318:~/TDengine-server-2.0.13.0#
+root@c452519b0f9b:~/TDengine-server-2.0.20.13# 
 ```
 - **docker exec**：通过 docker exec 命令进入容器，如果退出，容器不会停止。
 - **-i**：进入交互模式。
 - **-t**：指定一个终端。
- **cdf548465318**：容器 ID，需要根据 docker ps 指令返回的值进行修改。
+- **c452519b0f9b**：容器 ID，需要根据 docker ps 指令返回的值进行修改。
 - **/bin/bash**：载入容器后运行 bash 来进行交互。
 4，进入容器后，执行 taos shell 客户端程序。
 ```bash
-$ root@cdf548465318:~/TDengine-server-2.0.13.0# taos
+$ root@c452519b0f9b:~/TDengine-server-2.0.20.13# taos
-Welcome to the TDengine shell from Linux, Client Version:2.0.13.0
+Welcome to the TDengine shell from Linux, Client Version:2.0.20.13
 Copyright (c) 2020 by TAOS Data, Inc. All rights reserved.
 taos> 
@@ -78,42 +79,71 @@ TDengine 终端成功连接服务端，打印出了欢迎消息和版本信息
 ```bash
 $ taos> q
-root@cdf548465318:~/TDengine-server-2.0.13.0#
+root@c452519b0f9b:~/TDengine-server-2.0.20.13#
 ```
 2，在命令行界面执行 taosdemo。
 ```bash
-$ root@cdf548465318:~/TDengine-server-2.0.13.0# taosdemo
+root@c452519b0f9b:~/TDengine-server-2.0.20.13# taosdemo
-###################################################################
-# Server IP:                         localhost:0
+taosdemo is simulating data generated by power equipments monitoring...
-# User:                              root
-# Password:                          taosdata
+host:                       127.0.0.1:6030
-# Use metric:                        true
+user:                       root
-# Datatype of Columns:               int int int int int int int float
+password:                   taosdata
-# Binary Length(If applicable):      -1
+configDir:                  
-# Number of Columns per record:      3
+resultFile:                 ./output.txt
-# Number of Threads:                 10
+thread num of insert data:  10
-# Number of Tables:                  10000
+thread num of create table: 10
-# Number of Data per Table:          100000
+top insert interval:        0
-# Records/Request:                   1000
+number of records per req:  30000
-# Database name:                     test
+max sql length:             1048576
-# Table prefix:                      t
+database count:             1
-# Delete method:                     0
+database[0]:
-# Test time:                         2021-04-13 02:05:20
+  database[0] name:      test
-###################################################################
+  drop:                  yes
+  replica:               1
+  precision:             ms
+  super table count:     1
+  super table[0]:
+      stbName:           meters
+      autoCreateTable:   no
+      childTblExists:    no
+      childTblCount:     10000
+      childTblPrefix:    d
+      dataSource:        rand
+      iface:             taosc
+      insertRows:        10000
+      interlaceRows:     0
+      disorderRange:     1000
+      disorderRatio:     0
+      maxSqlLen:         1048576
+      timeStampStep:     1
+      startTimestamp:    2017-07-14 10:40:00.000
+      sampleFormat:      
+      sampleFile:        
+      tagsFile:          
+      columnCount:       3
+column[0]:FLOAT column[1]:INT column[2]:FLOAT 
+      tagCount:            2
+        tag[0]:INT tag[1]:BINARY(16) 
+         Press enter key to continue or Ctrl-C to stop
 ```
-回车后，该命令将新建一个数据库 test，并且自动创建一张超级表 meters，并以超级表 meters 为模版创建了 1 万张表，表名从 "t0" 到 "t9999"。每张表有 10 万条记录，每条记录有 f1，f2，f3 三个字段，时间戳 ts 字段从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:41:39 999"。每张表带有 areaid 和 loc 两个标签 TAG，areaid 被设置为 1 到 10，loc 被设置为 "beijing" 或 "shanghai"。
+回车后，该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "beijing" 或者 "shanghai"。
+执行这条命令大概需要几分钟，最后共插入 1 亿条记录。
 3，进入 TDengine 终端，查看 taosdemo 生成的数据。
 - **进入命令行。**
 ```bash
-$ root@cdf548465318:~/TDengine-server-2.0.13.0# taos
+$ root@c452519b0f9b:~/TDengine-server-2.0.20.13# taos
-Welcome to the TDengine shell from Linux, Client Version:2.0.13.0
+Welcome to the TDengine shell from Linux, Client Version:2.0.20.13
 Copyright (c) 2020 by TAOS Data, Inc. All rights reserved.
 taos> 
@@ -124,8 +154,8 @@ taos>
 ```bash
 $ taos> show databases;
  name        |      created_time       |   ntables   |   vgroups   |    ···
-  test        | 2021-04-13 02:14:15.950 |       10000 |           6 |    ···
+  test        | 2021-08-18 06:01:11.021 |       10000 |           6 |    ···
-  log         | 2021-04-12 09:36:37.549 |           4 |           1 |	   ···
+  log         | 2021-08-18 05:51:51.065 |           4 |           1 |	   ···
 ```
@@ -137,9 +167,9 @@ Database changed.
 $ taos> show stables;
              name              |      created_time       | columns |  tags  |   tables    |
-=====================================================================================
+============================================================================================
-       meters            | 2021-04-13 02:14:15.955 |       4 |      2 |       10000 |
+ meters                         | 2021-08-18 06:01:11.116 |       4 |      2 |       10000 |
-Query OK, 1 row(s) in set (0.001737s)
+Query OK, 1 row(s) in set (0.003259s)
 ```
@@ -147,42 +177,45 @@ Query OK, 1 row(s) in set (0.001737s)
 ```bash
 $ taos> select * from test.t0 limit 10;
-           ts            |     f1      |     f2      |     f3      |
-====================================================================
+DB error: Table does not exist (0.002857s)
- 2017-07-14 02:40:01.000 |           3 |           9 |           0 |
+taos> select * from test.d0 limit 10;
- 2017-07-14 02:40:02.000 |           0 |           1 |           2 |
+           ts            |       current        |   voltage   |        phase         |
- 2017-07-14 02:40:03.000 |           7 |           2 |           3 |
+======================================================================================
- 2017-07-14 02:40:04.000 |           9 |           4 |           5 |
+ 2017-07-14 10:40:00.000 |             10.12072 |         223 |              0.34167 |
- 2017-07-14 02:40:05.000 |           1 |           2 |           5 |
+ 2017-07-14 10:40:00.001 |             10.16103 |         224 |              0.34445 |
- 2017-07-14 02:40:06.000 |           6 |           3 |           2 |
+ 2017-07-14 10:40:00.002 |             10.00204 |         220 |              0.33334 |
- 2017-07-14 02:40:07.000 |           4 |           7 |           8 |
+ 2017-07-14 10:40:00.003 |             10.00030 |         220 |              0.33333 |
- 2017-07-14 02:40:08.000 |           4 |           6 |           6 |
+ 2017-07-14 10:40:00.004 |              9.84029 |         216 |              0.32222 |
- 2017-07-14 02:40:09.000 |           5 |           7 |           7 |
+ 2017-07-14 10:40:00.005 |              9.88028 |         217 |              0.32500 |
- 2017-07-14 02:40:10.000 |           1 |           5 |           0 |
+ 2017-07-14 10:40:00.006 |              9.88110 |         217 |              0.32500 |
-Query OK, 10 row(s) in set (0.003638s)
+ 2017-07-14 10:40:00.007 |             10.08137 |         222 |              0.33889 |
+ 2017-07-14 10:40:00.008 |             10.12063 |         223 |              0.34167 |
+ 2017-07-14 10:40:00.009 |             10.16086 |         224 |              0.34445 |
+Query OK, 10 row(s) in set (0.016791s)
 ```
- **查看 t0 表的标签值。**
+- **查看 d0 表的标签值。**
 ```bash
-$ taos> select areaid, loc from test.t0;
+$ taos> select groupid, location from test.d0;
-   areaid    |    loc     |
+   groupid   |     location     |
-===========================
+=================================
-          10 | shanghai   |
+           0 | shanghai         |
-Query OK, 1 row(s) in set (0.002904s)
+Query OK, 1 row(s) in set (0.003490s)
 ```
 ## 停止正在 Docker 中运行的 TDengine 服务
 ```bash
-$ docker stop cdf548465318
+$ docker stop tdengine
-cdf548465318
+tdengine
 ```
 - **docker stop**：通过 docker stop 停止指定的正在运行中的 docker 镜像。
- **cdf548465318**：容器 ID，根据 docker ps 指令返回的结果进行修改。
+- **tdengine**：容器名称。
 ## 编程开发时连接在 Docker 中的 TDengine
@@ -195,7 +228,7 @@ $ docker run -d -v /etc/taos:/etc/taos -P 6041:6041 tdengine/tdengine
 526aa188da767ae94b244226a2b2eec2b5f17dd8eff592893d9ec0cd0f3a1ccd
 $ curl -u root:taosdata -d 'show databases' 127.0.0.1:6041/rest/sql
-{"status":"succ","head":["name","created_time","ntables","vgroups","replica","quorum","days","keep1,keep2,keep(D)","cache(MB)","blocks","minrows","maxrows","wallevel","fsync","comp","precision","status"],"data":[],"rows":0}
+{"status":"succ","head":["name","created_time","ntables","vgroups","replica","quorum","days","keep0,keep1,keep(D)","cache(MB)","blocks","minrows","maxrows","wallevel","fsync","comp","cachelast","precision","update","status"],"column_meta":[["name",8,32],["created_time",9,8],["ntables",4,4],["vgroups",4,4],["replica",3,2],["quorum",3,2],["days",3,2],["keep0,keep1,keep(D)",8,24],["cache(MB)",4,4],["blocks",4,4],["minrows",4,4],["maxrows",4,4],["wallevel",2,1],["fsync",4,4],["comp",2,1],["cachelast",2,1],["precision",8,3],["update",2,1],["status",8,10]],"data":[["test","2021-08-18 06:01:11.021",10000,4,1,1,10,"3650,3650,3650",16,6,100,4096,1,3000,2,0,"ms",0,"ready"],["log","2021-08-18 05:51:51.065",4,1,1,1,10,"30,30,30",1,3,100,4096,1,3000,2,0,"us",0,"ready"]],"rows":2}
 ```
 - 第一条命令，启动一个运行了 TDengine 的 docker 容器，并且将容器的 6041 端口映射到宿主机的 6041 端口上。
@@ -206,6 +239,5 @@ $ curl -u root:taosdata -d 'show databases' 127.0.0.1:6041/rest/sql
 2，直接通过 exec 命令，进入到 docker 容器中去做开发。也即，把程序代码放在 TDengine 服务端所在的同一个 Docker 容器中，连接容器本地的 TDengine 服务。
 ```bash
-$ docker exec -it 526aa188da /bin/bash
+$ docker exec -it tdengine /bin/bash
 ```
--- a/documentation20/cn/04.model/docs.md
+++ b/documentation20/cn/04.model/docs.md
@@ -2,7 +2,7 @@
 # TDengine数据建模
-TDengine采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库的设计，超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
+TDengine采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库、超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
 关于数据建模请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1945.html)。

--- a/documentation20/cn/08.connector/01.java/docs.md
+++ b/documentation20/cn/08.connector/01.java/docs.md
@@ -2,8 +2,6 @@
 ## 总体介绍
-TDengine 提供了遵循 JDBC 标准（3.0）API 规范的 `taos-jdbcdriver` 实现，可在 maven 的中央仓库 [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver) 搜索下载。
 `taos-jdbcdriver` 的实现包括 2 种形式： JDBC-JNI 和 JDBC-RESTful（taos-jdbcdriver-2.0.18 开始支持 JDBC-RESTful）。 JDBC-JNI 通过调用客户端 libtaos.so（或 taos.dll ）的本地方法实现， JDBC-RESTful 则在内部封装了 RESTful 接口实现。
 ![tdengine-connector](page://images/tdengine-jdbc-connector.png)
@@ -14,12 +12,10 @@ TDengine 提供了遵循 JDBC 标准（3.0）API 规范的 `taos-jdbcdriver` 实
 * RESTful：应用将 SQL 发送给位于物理节点2（pnode2）上的 RESTful 连接器，再调用客户端 API（libtaos.so）。
 * JDBC-RESTful：Java 应用通过 JDBC-RESTful 的 API ，将 SQL 封装成一个 RESTful 请求，发送给物理节点2的 RESTful 连接器。
-TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致，但时序空间数据库与关系对象型数据库服务的对象和技术特征存在差异，导致 `taos-jdbcdriver` 与传统的 JDBC driver 也存在一定差异。在使用时需要注意以下几点：
+TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致，但TDengine与关系对象型数据库的使用场景和技术特征存在差异，导致 `taos-jdbcdriver` 与传统的 JDBC driver 也存在一定差异。在使用时需要注意以下几点：
 * TDengine 目前不支持针对单条数据记录的删除操作。
 * 目前不支持事务操作。
-* 目前不支持嵌套查询（nested query）。
-* 对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet 还没关闭的情况下执行了新的查询，taos-jdbcdriver 会自动关闭上一个 ResultSet。
 ### JDBC-JNI和JDBC-RESTful的对比
@@ -50,9 +46,12 @@ TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致
 </tr>
 </table>
-注意：与 JNI 方式不同，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，RESTful 下所有对表名、超级表名的引用都需要指定数据库名前缀。
+注意：与 JNI 方式不同，RESTful 接口是无状态的。在使用JDBC-RESTful时，需要在sql中指定表、超级表的数据库名称。（从 TDengine 2.1.8.0 版本开始，也可以在 RESTful url 中指定当前 SQL 语句所使用的默认数据库名。）例如：
+```sql
+INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(now, 24.6);
+```
-### <a class="anchor" id="version"></a>TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
+## <a class="anchor" id="version"></a>TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
 | taos-jdbcdriver 版本 | TDengine 版本     | JDK 版本 |
 | -------------------- | ----------------- | -------- |
@@ -65,7 +64,7 @@ TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致
 | 1.0.2                | 1.6.1.x 及以上    | 1.8.x    |
 | 1.0.1                | 1.6.1.x 及以上    | 1.8.x    |
-### TDengine DataType 和 Java DataType
+## TDengine DataType 和 Java DataType
 TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对应类型转换如下：
@@ -82,36 +81,29 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
 | BINARY            | byte array         |
 | NCHAR             | java.lang.String   |
-## 安装
+## 安装Java Connector
-Java连接器支持的系统有： Linux 64/Windows x64/Windows x86。
-**安装前准备：**
- 已安装TDengine服务器端
+### 安装前准备
- 已安装好TDengine应用驱动，具体请参照 [安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver) 章节
-TDengine 为了方便 Java 应用使用，遵循 JDBC 标准(3.0)API 规范提供了 `taos-jdbcdriver` 实现。可以通过 [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver) 搜索并下载。
+使用Java Connector连接数据库前，需要具备以下条件：
+1. Linux或Windows操作系统
-由于 TDengine 的应用驱动是使用C语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
+2. Java 1.8以上运行时环境
+3. TDengine-client（使用JDBC-JNI时必须，使用JDBC-RESTful时非必须）
+**注意**：由于 TDengine 的应用驱动是使用C语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
 - libtaos.so 在 Linux 系统中成功安装 TDengine 后，依赖的本地函数库 libtaos.so 文件会被自动拷贝至 /usr/lib/libtaos.so，该目录包含在 Linux 自动扫描路径上，无需单独指定。
 - taos.dll 在 Windows 系统中安装完客户端之后，驱动包依赖的 taos.dll 文件会自动拷贝到系统默认搜索路径 C:/Windows/System32 下，同样无需要单独指定。
-注意：在 Windows 环境开发时需要安装 TDengine 对应的 [windows 客户端](https://www.taosdata.com/cn/all-downloads/#TDengine-Windows-Client)，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端](https://www.taosdata.com/cn/getting-started/#快速上手) 连接远程 TDengine Server。
+**注意**：在 Windows 环境开发时需要安装 TDengine 对应的 [windows 客户端](https://www.taosdata.com/cn/all-downloads/#TDengine-Windows-Client)，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端](https://www.taosdata.com/cn/getting-started/#快速上手) 连接远程 TDengine Server。
-### 如何获取 TAOS-JDBCDriver
-**maven仓库**
+### 通过maven获取JDBC driver
 目前 taos-jdbcdriver 已经发布到 [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver) 仓库，且各大仓库都已同步。
 - [sonatype](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver)
 - [mvnrepository](https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver)
 - [maven.aliyun](https://maven.aliyun.com/mvn/search)
-maven 项目中使用如下 pom.xml 配置即可：
+maven 项目中，在pom.xml 中添加以下依赖：
 ```xml-dtd
 <dependency>
 <groupId>com.taosdata.jdbc</groupId>
@@ -119,32 +111,17 @@ maven 项目中使用如下 pom.xml 配置即可：
 <version>2.0.18</version>
 </dependency>
 ```
-**源码编译打包**
-下载 TDengine 源码之后，进入 taos-jdbcdriver 源码目录 `src/connector/jdbc` 执行 `mvn clean package -Dmaven.test.skip=true` 即可生成相应 jar 包。
-### 示例程序
+### 通过源码编译获取JDBC driver
-示例程序源码位于install_directory/examples/JDBC，有如下目录：
+可以通过下载TDengine的源码，自己编译最新版本的java connector
+```shell
-JDBCDemo                JDBC示例源程序
+git clone https://github.com/taosdata/TDengine.git
+cd TDengine/src/connector/jdbc
-JDBCConnectorChecker    JDBC安装校验源程序及jar包
+mvn clean package -Dmaven.test.skip=true
-Springbootdemo          springboot示例源程序
-SpringJdbcTemplate      SpringJDBC模板
-### 安装验证
-运行如下指令：
-```Bash
-cd {install_directory}/examples/JDBC/JDBCConnectorChecker
-java -jar JDBCConnectorChecker.jar -host <fqdn>
 ```
-验证通过将打印出成功信息。
+编译后，在target目录下会产生taos-jdbcdriver-2.0.XX-dist.jar的jar包。
 ## Java连接器的使用
@@ -163,13 +140,11 @@ Connection conn = DriverManager.getConnection(jdbcUrl);
 以上示例，使用 **JDBC-RESTful** 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
 使用 JDBC-RESTful 接口，不需要依赖本地函数库。与 JDBC-JNI 相比，仅需要：
 1. driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
 2. jdbcUrl 以“jdbc:TAOS-RS://”开头；
 3. 使用 6041 作为连接端口。
 如果希望获得更好的写入和查询性能，Java 应用可以使用 **JDBC-JNI** 的driver，如下所示：
 ```java
 Class.forName("com.taosdata.jdbc.TSDBDriver");
 String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
@@ -178,15 +153,9 @@ Connection conn = DriverManager.getConnection(jdbcUrl);
 以上示例，使用了 JDBC-JNI 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
-**注意**：使用 JDBC-JNI 的 driver，taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
+**注意**：使用 JDBC-JNI 的 driver，taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库（Linux 下是 libtaos.so；Windows 下是 taos.dll）。
-* libtaos.so
+> 在 Windows 环境开发时需要安装 TDengine 对应的 [windows 客户端](https://www.taosdata.com/cn/all-downloads/#TDengine-Windows-Client)，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端](https://www.taosdata.com/cn/getting-started/#%E5%AE%A2%E6%88%B7%E7%AB%AF) 连接远程 TDengine Server。
-  在 Linux 系统中成功安装 TDengine 后，依赖的本地函数库 libtaos.so 文件会被自动拷贝至 /usr/lib/libtaos.so，该目录包含在 Linux 自动扫描路径上，无需单独指定。
-* taos.dll
-  在 Windows 系统中安装完客户端之后，驱动包依赖的 taos.dll 文件会自动拷贝到系统默认搜索路径 C:/Windows/System32 下，同样无需要单独指定。
-> 在 Windows 环境开发时需要安装 TDengine 对应的 [windows 客户端][14]，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端][15] 连接远程 TDengine Server。
 JDBC-JNI 的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。
@@ -194,12 +163,15 @@ TDengine 的 JDBC URL 规范格式为：
 `jdbc:[TAOS|TAOS-RS]://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
 url中的配置参数如下：
-* user：登录 TDengine 用户名，默认值 root。
+* user：登录 TDengine 用户名，默认值 'root'。
-* password：用户登录密码，默认值 taosdata。
+* password：用户登录密码，默认值 'taosdata'。
-* cfgdir：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
+* cfgdir：客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
 * charset：客户端使用的字符集，默认值为系统字符集。
 * locale：客户端语言环境，默认值系统当前 locale。
 * timezone：客户端使用的时区，默认值为系统当前时区。
+* batchfetch: 仅在使用JDBC-JNI时生效。true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。
+* timestampFormat: 仅在使用JDBC-RESTful时生效. 'TIMESTAMP'：结果集中timestamp类型的字段为一个long值; 'UTC'：结果集中timestamp类型的字段为一个UTC时间格式的字符串; 'STRING'：结果集中timestamp类型的字段为一个本地时间格式的字符串。默认值为'STRING'。
+* batchErrorIgnore：true：在执行Statement的executeBatch时，如果中间有一条sql执行失败，继续执行下面的sq了。false：不再执行失败sql后的任何语句。默认值为：false。
 #### 指定URL和Properties获取连接
@@ -222,12 +194,15 @@ public Connection getConn() throws Exception{
 以上示例，建立一个到 hostname 为 taosdemo.com，端口为 6030，数据库名为 test 的连接。注释为使用 JDBC-RESTful 时的方法。这个连接在 url 中指定了用户名(user)为 root，密码（password）为 taosdata，并在 connProps 中指定了使用的字符集、语言环境、时区等信息。
 properties 中的配置参数如下：
-* TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 root。
+* TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 'root'。
-* TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 taosdata。
+* TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 'taosdata'。
-* TSDBDriver.PROPERTY_KEY_CONFIG_DIR：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
+* TSDBDriver.PROPERTY_KEY_CONFIG_DIR：客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
 * TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
 * TSDBDriver.PROPERTY_KEY_LOCALE：客户端语言环境，默认值系统当前 locale。
 * TSDBDriver.PROPERTY_KEY_TIME_ZONE：客户端使用的时区，默认值为系统当前时区。
+* TSDBDriver.PROPERTY_KEY_BATCH_LOAD: 仅在使用JDBC-JNI时生效。true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。
+* TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT: 仅在使用JDBC-RESTful时生效. 'TIMESTAMP'：结果集中timestamp类型的字段为一个long值; 'UTC'：结果集中timestamp类型的字段为一个UTC时间格式的字符串; 'STRING'：结果集中timestamp类型的字段为一个本地时间格式的字符串。默认值为'STRING'。
+* TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE：true：在执行Statement的executeBatch时，如果中间有一条sql执行失败，继续执行下面的sq了。false：不再执行失败sql后的任何语句。默认值为：false。
 #### 使用客户端配置文件建立连接
@@ -265,6 +240,7 @@ secondEp              cluster_node2:6030
 ```
 以上示例，jdbc 会使用客户端的配置文件，建立到 hostname 为 cluster_node1、端口为 6030、数据库名为 test 的连接。当集群中 firstEp 节点失效时，JDBC 会尝试使用 secondEp 连接集群。
 TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可以正常建立到集群的连接。
 > 注意：这里的配置文件指的是调用 JDBC Connector 的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值 C://TDengine/cfg/taos.cfg。
@@ -348,6 +324,7 @@ try (Statement statement = connection.createStatement()) {
 ```
 JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（错误码在0x2301到0x2350之间），JNI方法的报错（错误码在0x2351到0x2400之间），TDengine其他功能模块的报错。
 具体的错误码请参考：
 * https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
 * https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
@@ -428,11 +405,12 @@ public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
 public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 ```
 其中 setString 和 setNString 都要求用户在 size 参数里声明表定义中对应列的列宽。
-### <a class="anchor" id="subscribe"></a>订阅
+## <a class="anchor" id="subscribe"></a>订阅
-#### 创建
+### 创建
 ```java
 TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from meters", false);
@@ -446,7 +424,7 @@ TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from met
 如上面的例子将使用 SQL 语句 `select * from meters` 创建一个名为 `topic` 的订阅，如果这个订阅已经存在，将继续之前的查询进度，而不是从头开始消费所有的数据。
-#### 消费数据
+### 消费数据
 ```java
 int total = 0;
@@ -464,7 +442,7 @@ while(true) {
 `consume` 方法返回一个结果集，其中包含从上次 `consume` 到目前为止的所有新数据。请务必按需选择合理的调用 `consume` 的频率（如例子中的 `Thread.sleep(1000)`），否则会给服务端造成不必要的压力。
-#### 关闭订阅
+### 关闭订阅
 ```java
 sub.close(true);
@@ -472,7 +450,7 @@ sub.close(true);
 `close` 方法关闭一个订阅。如果其参数为 `true` 表示保留订阅进度信息，后续可以创建同名订阅继续消费数据；如为 `false` 则不保留订阅进度。
-### 关闭资源
+## 关闭资源
 ```java
 resultSet.close();
@@ -484,19 +462,9 @@ conn.close();
 ## 与连接池使用
-**HikariCP**
+### HikariCP
-* 引入相应 HikariCP maven 依赖：
-```xml
-<dependency>
-    <groupId>com.zaxxer</groupId>
-    <artifactId>HikariCP</artifactId>
-    <version>3.4.1</version>
-</dependency>
-```
-* 使用示例如下：
+使用示例如下：
 ```java
 public static void main(String[] args) throws SQLException {
@@ -528,19 +496,9 @@ conn.close();
 > 通过 HikariDataSource.getConnection() 获取连接后，使用完成后需要调用 close() 方法，实际上它并不会关闭连接，只是放回连接池中。
 > 更多 HikariCP 使用问题请查看[官方说明](https://github.com/brettwooldridge/HikariCP)。
-**Druid**
+### Druid
-* 引入相应 Druid maven 依赖：
-```xml
+使用示例如下：
-<dependency>
-    <groupId>com.alibaba</groupId>
-    <artifactId>druid</artifactId>
-    <version>1.1.20</version>
-</dependency>
-```
-* 使用示例如下：
 ```java
 public static void main(String[] args) throws Exception {
@@ -586,6 +544,16 @@ Query OK, 1 row(s) in set (0.000141s)
 * Spring JdbcTemplate 中使用 taos-jdbcdriver，可参考 [SpringJdbcTemplate](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/SpringJdbcTemplate)
 * Springboot + Mybatis 中使用，可参考 [springbootdemo](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/springbootdemo)
+## 示例程序
+示例程序源码位于TDengine/test/examples/JDBC下:
+* JDBCDemo：JDBC示例源程序
+* JDBCConnectorChecker：JDBC安装校验源程序及jar包
+* Springbootdemo：springboot示例源程序
+* SpringJdbcTemplate：SpringJDBC模板
+请参考：[JDBC example](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC)
 ## 常见问题
 * java.lang.UnsatisfiedLinkError: no taos in java.library.path

--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -315,10 +315,6 @@ TDengine的异步API均采用非阻塞调用模式。应用程序可以用多线
 1. 调用 `taos_stmt_init` 创建参数绑定对象；
 2. 调用 `taos_stmt_prepare` 解析 INSERT 语句；
 3. 如果 INSERT 语句中预留了表名但没有预留 TAGS，那么调用 `taos_stmt_set_tbname` 来设置表名；
-  * 从 2.1.6.0 版本开始，对于向一个超级表下的多个子表同时写入数据（每个子表写入的数据较少，可能只有一行）的情形，提供了一个专用的优化接口 `taos_stmt_set_sub_tbname`，可以通过提前载入 meta 数据以及避免对 SQL 语法的重复解析来节省总体的处理时间（但这个优化方法并不支持自动建表语法）。具体使用方法如下：
-    1. 必须先提前调用 `taos_load_table_info` 来加载所有需要的超级表和子表的 table meta；
-    2. 然后对一个超级表的第一个子表调用 `taos_stmt_set_tbname` 来设置表名；
-    3. 后续子表用 `taos_stmt_set_sub_tbname` 来设置表名。
 4. 如果 INSERT 语句中既预留了表名又预留了 TAGS（例如 INSERT 语句采取的是自动建表的方式），那么调用 `taos_stmt_set_tbname_tags` 来设置表名和 TAGS 的值；
 5. 调用 `taos_stmt_bind_param_batch` 以多列的方式设置 VALUES 的值，或者调用 `taos_stmt_bind_param` 以单行的方式设置 VALUES 的值；
 6. 调用 `taos_stmt_add_batch` 把当前绑定的参数加入批处理；
@@ -362,12 +358,6 @@ typedef struct TAOS_BIND {
  （2.1.1.0 版本新增，仅支持用于替换 INSERT 语句中的参数值）  
  当 SQL 语句中的表名使用了 `?` 占位时，可以使用此函数绑定一个具体的表名。
- `int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name)`
-  （2.1.6.0 版本新增，仅支持用于替换 INSERT 语句中、属于同一个超级表下的多个子表中、作为写入目标的第 2 个到第 n 个子表的表名）  
-  当 SQL 语句中的表名使用了 `?` 占位时，如果想要一批写入的表是多个属于同一个超级表的子表，那么可以使用此函数绑定除第一个子表之外的其他子表的表名。  
-  *注意：*在使用时，客户端必须先调用 `taos_load_table_info` 来加载所有需要的超级表和子表的 table meta，然后对一个超级表的第一个子表调用 `taos_stmt_set_tbname`，后续子表用 `taos_stmt_set_sub_tbname`。
 - `int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags)`
  （2.1.2.0 版本新增，仅支持用于替换 INSERT 语句中的参数值）  
@@ -664,22 +654,23 @@ conn.close()
 为支持各种不同类型平台的开发，TDengine 提供符合 REST 设计标准的 API，即 RESTful API。为最大程度降低学习成本，不同于其他数据库 RESTful API 的设计方法，TDengine 直接通过 HTTP POST 请求 BODY 中包含的 SQL 语句来操作数据库，仅需要一个 URL。RESTful 连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。
-注意：与标准连接器的一个区别是，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，所有对表名、超级表名的引用都需要指定数据库名前缀。
+注意：与标准连接器的一个区别是，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，所有对表名、超级表名的引用都需要指定数据库名前缀。（从 2.1.8.0 版本开始，支持在 RESTful url 中指定 db_name，这时如果 SQL 语句中没有指定数据库名前缀的话，会使用 url 中指定的这个 db_name。）
 ### 安装
-RESTful接口不依赖于任何TDengine的库，因此客户端不需要安装任何TDengine的库，只要客户端的开发语言支持HTTP协议即可。
+RESTful 接口不依赖于任何 TDengine 的库，因此客户端不需要安装任何 TDengine 的库，只要客户端的开发语言支持 HTTP 协议即可。
 ### 验证
-在已经安装TDengine服务器端的情况下，可以按照如下方式进行验证。
+在已经安装 TDengine 服务器端的情况下，可以按照如下方式进行验证。
-下面以Ubuntu环境中使用curl工具（确认已经安装）来验证RESTful接口的正常。
+下面以 Ubuntu 环境中使用 curl 工具（确认已经安装）来验证 RESTful 接口的正常。
-下面示例是列出所有的数据库，请把h1.taosdata.com和6041（缺省值）替换为实际运行的TDengine服务fqdn和端口号：
+下面示例是列出所有的数据库，请把 h1.taosdata.com 和 6041（缺省值）替换为实际运行的 TDengine 服务 fqdn 和端口号：
 ```html
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'show databases;' h1.taosdata.com:6041/rest/sql
 ```
 返回值结果如下表示验证通过：
 ```json
 {
@@ -692,22 +683,23 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'show databases;' h1.taos
 }
 ```
-### RESTful连接器的使用
+### RESTful 连接器的使用
-#### HTTP请求格式 
+#### HTTP 请求格式 
 ```
-http://<fqdn>:<port>/rest/sql
+http://<fqdn>:<port>/rest/sql/[db_name]
 ```
 参数说明：
- fqnd: 集群中的任一台主机FQDN或IP地址
+- fqnd: 集群中的任一台主机 FQDN 或 IP 地址
- port: 配置文件中httpPort配置项，缺省为6041
+- port: 配置文件中 httpPort 配置项，缺省为 6041
+- db_name: 可选参数，指定本次所执行的 SQL 语句的默认数据库库名。（从 2.1.8.0 版本开始支持）
-例如：http://h1.taos.com:6041/rest/sql 是指向地址为h1.taos.com:6041的url。
+例如：http://h1.taos.com:6041/rest/sql/test 是指向地址为 h1.taos.com:6041 的 url，并将默认使用的数据库库名设置为 test。
-HTTP请求的Header里需带有身份认证信息，TDengine支持Basic认证与自定义认证两种机制，后续版本将提供标准安全的数字签名机制来做身份验证。
+HTTP 请求的 Header 里需带有身份认证信息，TDengine 支持 Basic 认证与自定义认证两种机制，后续版本将提供标准安全的数字签名机制来做身份验证。
 - 自定义身份认证信息如下所示（<token>稍后介绍）
@@ -721,25 +713,25 @@ Authorization: Taosd <TOKEN>
 Authorization: Basic <TOKEN>
 ```
-HTTP请求的BODY里就是一个完整的SQL语句，SQL语句中的数据表应提供数据库前缀，例如\<db-name>.\<tb-name>。如果表名不带数据库前缀，系统会返回错误。因为HTTP模块只是一个简单的转发，没有当前DB的概念。 
+HTTP 请求的 BODY 里就是一个完整的 SQL 语句，SQL 语句中的数据表应提供数据库前缀，例如 \<db_name>.\<tb_name>。如果表名不带数据库前缀，又没有在 url 中指定数据库名的话，系统会返回错误。因为 HTTP 模块只是一个简单的转发，没有当前 DB 的概念。 
-使用curl通过自定义身份认证方式来发起一个HTTP Request，语法如下：
+使用 curl 通过自定义身份认证方式来发起一个 HTTP Request，语法如下：
 ```bash
-curl -H 'Authorization: Basic <TOKEN>' -d '<SQL>' <ip>:<PORT>/rest/sql
+curl -H 'Authorization: Basic <TOKEN>' -d '<SQL>' <ip>:<PORT>/rest/sql/[db_name]
 ```
 或者
 ```bash
-curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
+curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql/[db_name]
 ```
-其中，`TOKEN`为`{username}:{password}`经过Base64编码之后的字符串，例如`root:taosdata`编码后为`cm9vdDp0YW9zZGF0YQ==`
+其中，`TOKEN` 为 `{username}:{password}` 经过 Base64 编码之后的字符串，例如 `root:taosdata` 编码后为 `cm9vdDp0YW9zZGF0YQ==`
-### HTTP返回格式
+### HTTP 返回格式
-返回值为JSON格式，如下:
+返回值为 JSON 格式，如下:
 ```json
 {
@@ -757,9 +749,9 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 说明：
 - status: 告知操作结果是成功还是失败。
- head: 表的定义，如果不返回结果集，则仅有一列“affected_rows”。（从 2.0.17.0 版本开始，建议不要依赖 head 返回值来判断数据列类型，而推荐使用 column_meta。在未来版本中，有可能会从返回值中去掉 head 这一项。）
+- head: 表的定义，如果不返回结果集，则仅有一列 “affected_rows”。（从 2.0.17.0 版本开始，建议不要依赖 head 返回值来判断数据列类型，而推荐使用 column_meta。在未来版本中，有可能会从返回值中去掉 head 这一项。）
 - column_meta: 从 2.0.17.0 版本开始，返回值中增加这一项来说明 data 里每一列的数据类型。具体每个列会用三个值来说明，分别为：列名、列类型、类型长度。例如`["current",6,4]`表示列名为“current”；列类型为 6，也即 float 类型；类型长度为 4，也即对应 4 个字节表示的 float。如果列类型为 binary 或 nchar，则类型长度表示该列最多可以保存的内容长度，而不是本次返回值中的具体数据长度。当列类型是 nchar 的时候，其类型长度表示可以保存的 unicode 字符数量，而不是 bytes。
- data: 具体返回的数据，一行一行的呈现，如果不返回结果集，那么就仅有[[affected_rows]]。data 中每一行的数据列顺序，与 column_meta 中描述数据列的顺序完全一致。
+- data: 具体返回的数据，一行一行的呈现，如果不返回结果集，那么就仅有 [[affected_rows]]。data 中每一行的数据列顺序，与 column_meta 中描述数据列的顺序完全一致。
 - rows: 表明总共多少行数据。
 column_meta 中的列类型说明：
@@ -776,13 +768,13 @@ column_meta 中的列类型说明：
 ### 自定义授权码
-HTTP请求中需要带有授权码`<TOKEN>`，用于身份识别。授权码通常由管理员提供，可简单的通过发送`HTTP GET`请求来获取授权码，操作如下：
+HTTP 请求中需要带有授权码 `<TOKEN>`，用于身份识别。授权码通常由管理员提供，可简单的通过发送 `HTTP GET` 请求来获取授权码，操作如下：
 ```bash
 curl http://<fqnd>:<port>/rest/login/<username>/<password>
 ```
-其中，`fqdn`是TDengine数据库的fqdn或ip地址，port是TDengine服务的端口号，`username`为数据库用户名，`password`为数据库密码，返回值为`JSON`格式，各字段含义如下：
+其中，`fqdn` 是 TDengine 数据库的 fqdn 或 ip 地址，port 是 TDengine 服务的端口号，`username` 为数据库用户名，`password` 为数据库密码，返回值为 `JSON` 格式，各字段含义如下：
 - status：请求结果的标志位
@@ -808,7 +800,7 @@ curl http://192.168.0.1:6041/rest/login/root/taosdata
 ### 使用示例
- 在demo库里查询表d1001的所有记录： 
+- 在 demo 库里查询表 d1001 的所有记录： 
 ```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sql
@@ -828,7 +820,7 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 }
 ```
- 创建库demo：
+- 创建库 demo：
 ```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 192.168.0.1:6041/rest/sql
@@ -847,9 +839,9 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 19
 ### 其他用法
-#### 结果集采用Unix时间戳
+#### 结果集采用 Unix 时间戳
-HTTP请求URL采用`sqlt`时，返回结果集的时间戳将采用Unix时间戳格式表示，例如
+HTTP 请求 URL 采用 `sqlt` 时，返回结果集的时间戳将采用 Unix 时间戳格式表示，例如
 ```bash
 curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sqlt
@@ -870,9 +862,9 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 }
 ```
-#### 结果集采用UTC时间字符串
+#### 结果集采用 UTC 时间字符串
-HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间字符串表示，例如
+HTTP 请求 URL 采用 `sqlutc` 时，返回结果集的时间戳将采用 UTC 时间字符串表示，例如
 ```bash
  curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.t1' 192.168.0.1:6041/rest/sqlutc
 ```
@@ -894,13 +886,14 @@ HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间
 ### 重要配置项
-下面仅列出一些与RESTful接口有关的配置参数，其他系统参数请看配置文件里的说明。（注意：配置修改后，需要重启taosd服务才能生效）
+下面仅列出一些与 RESTful 接口有关的配置参数，其他系统参数请看配置文件里的说明。（注意：配置修改后，需要重启 taosd 服务才能生效）
- 对外提供RESTful服务的端口号，默认绑定到 6041（实际取值是 serverPort + 11，因此可以通过修改 serverPort 参数的设置来修改）
+- 对外提供 RESTful 服务的端口号，默认绑定到 6041（实际取值是 serverPort + 11，因此可以通过修改 serverPort 参数的设置来修改）。
- httpMaxThreads: 启动的线程数量，默认为2（2.0.17.0版本开始，默认值改为CPU核数的一半向下取整）
+- httpMaxThreads: 启动的线程数量，默认为 2（2.0.17.0 版本开始，默认值改为 CPU 核数的一半向下取整）。
- restfulRowLimit: 返回结果集（JSON格式）的最大条数，默认值为10240
+- restfulRowLimit: 返回结果集（JSON 格式）的最大条数，默认值为 10240。
- httpEnableCompress: 是否支持压缩，默认不支持，目前TDengine仅支持gzip压缩格式
+- httpEnableCompress: 是否支持压缩，默认不支持，目前 TDengine 仅支持 gzip 压缩格式。
- httpDebugFlag: 日志开关，默认131。131：仅错误和报警信息，135：调试信息，143：非常详细的调试信息，默认131
+- httpDebugFlag: 日志开关，默认 131。131：仅错误和报警信息，135：调试信息，143：非常详细的调试信息，默认 131。
+- httpDbNameMandatory: 是否必须在 RESTful url 中指定默认的数据库名。默认为 0，即关闭此检查。如果设置为 1，那么每个 RESTful url 中都必须设置一个默认数据库名，否则无论此时执行的 SQL 语句是否需要指定数据库，都会返回一个执行错误，拒绝执行此 SQL 语句。
 ## <a class="anchor" id="csharp"></a>CSharp Connector
@@ -976,13 +969,17 @@ Go连接器支持的系统有：
 **提示：建议Go版本是1.13及以上，并开启模块支持：**
 ```sh
-  go env -w GO111MODULE=on  
+go env -w GO111MODULE=on
-  go env -w GOPROXY=https://goproxy.io,direct  
+go env -w GOPROXY=https://goproxy.io,direct
 ```
 在taosdemo.go所在目录下进行编译和执行：
 ```sh
-  go mod init *demo*  
+go mod init taosdemo
-  go build   ./demo -h fqdn -p serverPort  
+go get github.com/taosdata/driver-go/taosSql
+# use win branch in Windows platform.
+#go get github.com/taosdata/driver-go/taosSql@win
+go build
+./taosdemo -h fqdn -p serverPort
 ```
 ### Go连接器的使用

--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -375,7 +375,7 @@ taos -C  或  taos --dump-config
    timezone GMT-8
    timezone Asia/Shanghai
    ```
-    均是合法的设置东八区时区的格式。
+    均是合法的设置东八区时区的格式。但需注意，Windows 下并不支持 `timezone Asia/Shanghai` 这样的写法，而必须写成 `timezone UTC-8`。
    时区的设置对于查询和写入SQL语句中非Unix时间戳的内容（时间戳字符串、关键词now的解析）产生影响。例如：
    ```sql
@@ -800,7 +800,7 @@ taos -n sync -P 6042 -h <fqdn of server>
 `taos -n speed -h <fqdn of server> -P 6030 -N 10 -l 10000000 -S TCP`
-从 2.1.7.0 版本开始，taos 工具新提供了一个网络速度诊断的模式，可以对一个正在运行中的 taosd 实例或者 `taos -n server` 方式模拟的一个服务端实例，以非压缩传输的方式进行网络测速。这个模式下可供调整的参数如下：
+从 2.1.8.0 版本开始，taos 工具新提供了一个网络速度诊断的模式，可以对一个正在运行中的 taosd 实例或者 `taos -n server` 方式模拟的一个服务端实例，以非压缩传输的方式进行网络测速。这个模式下可供调整的参数如下：
 -n：设为“speed”时，表示对网络速度进行诊断。
 -h：所要连接的服务端的 FQDN 或 ip 地址。如果不设置这一项，会使用本机 taos.cfg 文件中 FQDN 参数的设置作为默认值。
@@ -809,6 +809,15 @@ taos -n sync -P 6042 -h <fqdn of server>
 -l：单个网络包的大小（单位：字节）。最小值是 1024、最大值是 1024*1024*1024，默认值为 1000。
 -S：网络封包的类型。可以是 TCP 或 UDP，默认值为 TCP。
+#### FQDN 解析速度诊断
+`taos -n fqdn -h <fqdn of server>`
+从 2.1.8.0 版本开始，taos 工具新提供了一个 FQDN 解析速度的诊断模式，可以对一个目标 FQDN 地址尝试解析，并记录解析过程中所消耗的时间。这个模式下可供调整的参数如下：
+-n：设为“fqdn”时，表示对 FQDN 解析进行诊断。
+-h：所要解析的目标 FQDN 地址。如果不设置这一项，会使用本机 taos.cfg 文件中 FQDN 参数的设置作为默认值。
 #### 服务端日志
 taosd 服务端日志文件标志位 debugflag 默认为 131，在 debug 时往往需要将其提升到 135 或 143 。

--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -206,10 +206,6 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
    显示当前数据库下的所有数据表信息。
-    说明：可在 like 中使用通配符进行名称的匹配，这一通配符字符串最长不能超过 20 字节。（ 从 2.1.6.1 版本开始，通配符字符串的长度放宽到了 100 字节，并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串，将有可能严重影响 LIKE 操作的执行性能。）
-    通配符匹配：1）'%'（百分号）匹配0到任意个字符；2）'\_'下划线匹配单个任意字符。
 - **显示一个数据表的创建语句**
    ```mysql
@@ -718,15 +714,19 @@ Query OK, 1 row(s) in set (0.001091s)
 | =               | equal to                      | all types                                 |
 | <>              | not equal to                  | all types                                 |
 | between and     | within a certain range        | **`timestamp`** and all numeric types     |
-| in              | matches any value in a set    | all types except first column `timestamp` |
+| in              | match any value in a set      | all types except first column `timestamp` |
+| like            | match a wildcard string       | **`binary`** **`nchar`**                  |
 | %               | match with any char sequences | **`binary`** **`nchar`**                  |
 | _               | match with a single char      | **`binary`** **`nchar`**                  |
 1. <> 算子也可以写为 != ，请注意，这个算子不能用于数据表第一列的 timestamp 字段。
-2. 同时进行多个字段的范围过滤，需要使用关键词 AND 来连接不同的查询条件，暂不支持 OR 连接的不同列之间的查询过滤条件。
+2. like 算子使用通配符字符串进行匹配检查。
-3. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如： `((value > 20 AND value < 30) OR (value < 12))`。
+  * 在通配符字符串中：'%'（百分号）匹配 0 到任意个字符；'\_'（下划线）匹配单个任意字符。
-4. 从 2.0.17.0 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
+  * 通配符字符串最长不能超过 20 字节。（从 2.1.6.1 版本开始，通配符字符串的长度放宽到了 100 字节，并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串，将有可能严重影响 LIKE 操作的执行性能。）
-5. 从 2.1.4.0 版本开始，条件过滤开始支持 IN 算子，例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明：BOOL 类型写作 `{true, false}` 或 `{0, 1}` 均可，但不能写作 0、1 之外的整数；FLOAT 和 DOUBLE 类型会受到浮点数精度影响，集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功；TIMESTAMP 类型支持非主键的列。<!-- REPLACE_OPEN_TO_ENTERPRISE__IN_OPERATOR_AND_UNSIGNED_INTEGER -->
+3. 同时进行多个字段的范围过滤，需要使用关键词 AND 来连接不同的查询条件，暂不支持 OR 连接的不同列之间的查询过滤条件。
+4. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如： `((value > 20 AND value < 30) OR (value < 12))`。
+5. 从 2.0.17.0 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
+6. 从 2.1.4.0 版本开始，条件过滤开始支持 IN 算子，例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明：BOOL 类型写作 `{true, false}` 或 `{0, 1}` 均可，但不能写作 0、1 之外的整数；FLOAT 和 DOUBLE 类型会受到浮点数精度影响，集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功；TIMESTAMP 类型支持非主键的列。<!-- REPLACE_OPEN_TO_ENTERPRISE__IN_OPERATOR_AND_UNSIGNED_INTEGER -->
 <a class="anchor" id="union"></a>
 ### UNION ALL 操作符
@@ -1197,8 +1197,6 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    适用于：**表、超级表**。
-    说明：与LAST函数不同，LAST_ROW不支持时间范围限制，强制返回最后一条记录。
    限制：LAST_ROW()不能与INTERVAL一起使用。
    示例：

--- a/documentation20/en/00.index/docs.md
+++ b/documentation20/en/00.index/docs.md
@@ -71,7 +71,7 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 ## [Connector](/connector)
 - [C/C++ Connector](/connector#c-cpp): primary method to connect to TDengine server through libtaos client library
- [Java Connector(JDBC)]: driver for connecting to the server from Java applications using the JDBC API
+- [Java Connector(JDBC)](/connector/java): driver for connecting to the server from Java applications using the JDBC API
 - [Python Connector](/connector#python): driver for connecting to TDengine server from Python applications
 - [RESTful Connector](/connector#restful): a simple way to interact with TDengine via HTTP
 - [Go Connector](/connector#go): driver for connecting to TDengine server from Go applications

--- a/documentation20/en/08.connector/01.java/docs.md
+++ b/documentation20/en/08.connector/01.java/docs.md
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -194,6 +194,9 @@ keepColumnName            1
 # maximum number of rows returned by the restful interface
 # restfulRowLimit       10240
+# database name must be specified in restful interface if the following parameter is set, off by default
+# httpDbNameMandatory 1
 # The following parameter is used to limit the maximum number of lines in log files.
 # max number of lines per log filters
 # numOfLogLines         10000000

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

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

--- a/src/balance/src/bnScore.c
+++ b/src/balance/src/bnScore.c
@@ -116,8 +116,17 @@ void bnCleanupDnodes() {
 static void bnCheckDnodesSize(int32_t dnodesNum) {
  if (tsBnDnodes.maxSize <= dnodesNum) {
-    tsBnDnodes.maxSize = dnodesNum * 2;
+    int32_t maxSize = dnodesNum * 2;
-    tsBnDnodes.list = realloc(tsBnDnodes.list, tsBnDnodes.maxSize * sizeof(SDnodeObj *));
+    SDnodeObj** list1 = NULL;
+    int32_t retry = 0;
+    while(list1 == NULL && retry++ < 3) {
+      list1 = realloc(tsBnDnodes.list, maxSize * sizeof(SDnodeObj *));
+    }    
+    if(list1) {
+      tsBnDnodes.list = list1;
+      tsBnDnodes.maxSize = maxSize;
+    }
  }
 }

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

--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -50,6 +50,12 @@ void tscUnlockByThread(int64_t *lockedBy);
 int tsInsertInitialCheck(SSqlObj *pSql);
+void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
+void tscFreeRetrieveSup(SSqlObj *pSql);
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -36,7 +36,7 @@ extern "C" {
  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_CHILD_TABLE))
 #define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo) \
-  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo) || UTIL_TABLE_IS_TMP_TABLE(metaInfo)))
+  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo)))
 #define UTIL_TABLE_IS_TMP_TABLE(metaInfo) \
  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_TEMP_TABLE))
@@ -144,6 +144,7 @@ bool tscIsSessionWindowQuery(SQueryInfo* pQueryInfo);
 bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);
 bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo);
 bool tscGroupbyColumn(SQueryInfo* pQueryInfo);
+int32_t tscGetTopBotQueryExprIndex(SQueryInfo* pQueryInfo);
 bool tscIsTopBotQuery(SQueryInfo* pQueryInfo);
 bool hasTagValOutput(SQueryInfo* pQueryInfo);
 bool timeWindowInterpoRequired(SQueryInfo *pQueryInfo);
@@ -190,6 +191,7 @@ void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
 void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList);
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo);
 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize);
 void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
@@ -214,6 +216,7 @@ SExprInfo* tscExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t function
                           int16_t size);
 size_t     tscNumOfExprs(SQueryInfo* pQueryInfo);
+int32_t     tscExprTopBottomIndex(SQueryInfo* pQueryInfo);
 SExprInfo *tscExprGet(SQueryInfo* pQueryInfo, int32_t index);
 int32_t    tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
 int32_t    tscExprCopyAll(SArray* dst, const SArray* src, bool deepcopy);
@@ -362,6 +365,8 @@ STblCond* tsGetTableFilter(SArray* filters, uint64_t uid, int16_t idx);
 void tscRemoveCachedTableMeta(STableMetaInfo* pTableMetaInfo, uint64_t id);
+char* cloneCurrentDBName(SSqlObj* pSql);
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -38,6 +38,11 @@ extern "C" {
 #include "qUtil.h"
 #include "tcmdtype.h"
+typedef enum {
+  TAOS_REQ_FROM_SHELL,
+  TAOS_REQ_FROM_HTTP
+} SReqOrigin;
 // forward declaration
 struct SSqlInfo;
@@ -340,6 +345,7 @@ typedef struct STscObj {
  SRpcCorEpSet      *tscCorMgmtEpSet;
  pthread_mutex_t    mutex;
  int32_t            numOfObj; // number of sqlObj from this tscObj
+  SReqOrigin         from;
 } STscObj;
 typedef struct SSubqueryState {
@@ -486,6 +492,7 @@ bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
 void tscSetBoundColumnInfo(SParsedDataColInfo *pColInfo, SSchema *pSchema, int32_t numOfCols);
 char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql);
 int32_t tscInvalidOperationMsg(char *msg, const char *additionalInfo, const char *sql);
 int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* sql);

--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -363,15 +363,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      }
      if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT)) {  // stmt insert
-        STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-        code = tscGetTableMeta(pSql, pTableMetaInfo);
-        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-          taosReleaseRef(tscObjRef, pSql->self);
-          return;
-        } else {
-          assert(code == TSDB_CODE_SUCCESS);
-        }
        (*pSql->fp)(pSql->param, pSql, code);
      } else if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) { // file insert
        tscImportDataFromFile(pSql);

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

--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -206,6 +206,8 @@ static int normalStmtPrepare(STscStmt* stmt) {
        return code;
      }
      start = i + token.n;
+    } else if (token.type == TK_ILLEGAL) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(&stmt->pSql->cmd), "invalid sql");
    }
    i += token.n;
@@ -1527,8 +1529,9 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
  pCmd->insertParam.insertType = TSDB_QUERY_TYPE_STMT_INSERT;
  pCmd->insertParam.objectId = pSql->self;
-  pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+  char* sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+  if(sqlstr == NULL && pSql->sqlstr) free(pSql->sqlstr);  
+  pSql->sqlstr = sqlstr;
  if (pSql->sqlstr == NULL) {
    tscError("%p failed to malloc sql string buffer", pSql);
    STMT_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
@@ -1537,6 +1540,8 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
  pRes->qId = 0;
  pRes->numOfRows = 1;
+  registerSqlObj(pSql);
  strtolower(pSql->sqlstr, sql);
  tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
@@ -1546,8 +1551,6 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
    pSql->cmd.insertParam.numOfParams = 0;
    pSql->cmd.batchSize   = 0;
-    registerSqlObj(pSql);
    int32_t ret = stmtParseInsertTbTags(pSql, pStmt);
    if (ret != TSDB_CODE_SUCCESS) {
      STMT_RET(ret);

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -332,21 +332,41 @@ int tscSendMsgToServer(SSqlObj *pSql) {
      .code    = 0
  };
  rpcSendRequest(pObj->pRpcObj->pDnodeConn, &pSql->epSet, &rpcMsg, &pSql->rpcRid);
  return TSDB_CODE_SUCCESS;
 }
-static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
+// handle three situation
-  SRpcMsg* rpcMsg = pSchedMsg->ahandle;
+// 1. epset retry, only return last failure ep
-  SRpcEpSet* pEpSet = pSchedMsg->thandle;
+// 2. no epset retry, like 'taos -h invalidFqdn', return invalidFqdn
+// 3. other situation, no expected
+void tscSetFqdnErrorMsg(SSqlObj* pSql, SRpcEpSet* pEpSet) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlRes* pRes = &pSql->res;
+  char* msgBuf = tscGetErrorMsgPayload(pCmd);
+  if (pEpSet) {
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),pEpSet->fqdn[(pEpSet->inUse)%(pEpSet->numOfEps)]);
+  } else if (pCmd->command >= TSDB_SQL_MGMT) {
+    SRpcEpSet tEpset;
+    SRpcCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+    taosCorBeginRead(&pCorEpSet->version);
+    tEpset = pCorEpSet->epSet;
+    taosCorEndRead(&pCorEpSet->version);
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),tEpset.fqdn[(tEpset.inUse)%(tEpset.numOfEps)]);
+  } else {
+    sprintf(msgBuf, "%s", tstrerror(pRes->code));
+  }
+}
+void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
  TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
  if (pSql == NULL) {
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -357,15 +377,12 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
  SSqlCmd *pCmd = &pSql->cmd;
  pSql->rpcRid = -1;
  if (pObj->signature != pObj) {
    tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
    taosRemoveRef(tscObjRef, handle);
    taosReleaseRef(tscObjRef, handle);
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -377,8 +394,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
    taosRemoveRef(tscObjRef, handle);
    taosReleaseRef(tscObjRef, handle);
    rpcFreeCont(rpcMsg->pCont);
-    free(rpcMsg);
-    free(pEpSet);
    return;
  }
@@ -432,8 +447,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
        if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
          taosReleaseRef(tscObjRef, handle);
          rpcFreeCont(rpcMsg->pCont);
-          free(rpcMsg);
-          free(pEpSet);
          return;
        }
      }
@@ -500,28 +513,13 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
    if (rpcMsg->code != TSDB_CODE_SUCCESS) {
      pRes->code = rpcMsg->code;
    }
    rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
-    if (pRes->code == TSDB_CODE_RPC_FQDN_ERROR) {
+    if (rpcMsg->code == TSDB_CODE_RPC_FQDN_ERROR) {
      tscAllocPayload(pCmd, TSDB_FQDN_LEN + 64);
-      // handle three situation 
+      tscSetFqdnErrorMsg(pSql, pEpSet);
-      // 1. epset retry, only return last failure ep   
-      // 2. no epset retry, like 'taos -h invalidFqdn', return invalidFqdn 
-      // 3. other situation, no expected 
-      if (pEpSet) {
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s\"%s\"", tstrerror(pRes->code),pEpSet->fqdn[(pEpSet->inUse)%(pEpSet->numOfEps)]);
-      } else if (pCmd->command >= TSDB_SQL_MGMT) {
-        SRpcEpSet tEpset;
-        SRpcCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
-        taosCorBeginRead(&pCorEpSet->version); 
-        tEpset = pCorEpSet->epSet;   
-        taosCorEndRead(&pCorEpSet->version); 
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s\"%s\"", tstrerror(pRes->code),tEpset.fqdn[(tEpset.inUse)%(tEpset.numOfEps)]);
-      } else {
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s", tstrerror(pRes->code));
-      }
    }
    (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
  }
@@ -532,35 +530,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
  taosReleaseRef(tscObjRef, handle);
  rpcFreeCont(rpcMsg->pCont);
-  free(rpcMsg);
-  free(pEpSet);
-}
-void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
-  int64_t st = taosGetTimestampUs();
-  SSchedMsg schedMsg = {0};
-  schedMsg.fp = doProcessMsgFromServer;
-  SRpcMsg* rpcMsgCopy = calloc(1, sizeof(SRpcMsg));
-  memcpy(rpcMsgCopy, rpcMsg, sizeof(struct SRpcMsg));
-  schedMsg.ahandle = (void*)rpcMsgCopy;
-  SRpcEpSet* pEpSetCopy = NULL;
-  if (pEpSet != NULL) {
-    pEpSetCopy = calloc(1, sizeof(SRpcEpSet));
-    memcpy(pEpSetCopy, pEpSet, sizeof(SRpcEpSet));
-  }
-  schedMsg.thandle = (void*)pEpSetCopy;
-  schedMsg.msg = NULL;
-  taosScheduleTask(tscQhandle, &schedMsg);
-  int64_t et = taosGetTimestampUs();
-  if (et - st > 100) {
-    tscDebug("add message to task queue, elapsed time:%"PRId64, et - st);
-  }
 }
 int doBuildAndSendMsg(SSqlObj *pSql) {
@@ -733,8 +702,13 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql) {
    }
  }
-  return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + srcColFilterSize + srcTagFilterSize + exprSize + tsBufSize +
+  SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
-         tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
+  if (pCond->len > 0) {
+    srcColListSize += pCond->len;
+  }
+  return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + srcColFilterSize + srcTagFilterSize +
+         exprSize + tsBufSize + tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
 }
 static char *doSerializeTableInfo(SQueryTableMsg *pQueryMsg, SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, char *pMsg,
@@ -1429,7 +1403,6 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
 }
 int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  STscObj *pObj = pSql->pTscObj;
  SSqlCmd *pCmd = &pSql->cmd;
  pCmd->msgType = TSDB_MSG_TYPE_CM_SHOW;
  pCmd->payloadLen = sizeof(SShowMsg) + 100;
@@ -1452,9 +1425,9 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  }
  if (tNameIsEmpty(&pTableMetaInfo->name)) {
-    pthread_mutex_lock(&pObj->mutex);
+    char *p = cloneCurrentDBName(pSql);
-    tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));  
+    tstrncpy(pShowMsg->db, p, sizeof(pShowMsg->db));
-    pthread_mutex_unlock(&pObj->mutex);
+    tfree(p);
  } else {
    tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
  }
@@ -2951,10 +2924,14 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
  if (pTableMetaInfo->tableMetaCapacity != 0 && pTableMetaInfo->pTableMeta != NULL) {
    memset(pTableMetaInfo->pTableMeta, 0, pTableMetaInfo->tableMetaCapacity);
  }
-  taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity);
+  if (NULL == taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity)) {
+    tfree(pTableMetaInfo->pTableMeta);
+  }
  STableMeta* pMeta   = pTableMetaInfo->pTableMeta;
  STableMeta* pSTMeta = (STableMeta *)(pSql->pBuf);
  if (pMeta && pMeta->id.uid > 0) {
    // in case of child table, here only get the
    if (pMeta->tableType == TSDB_CHILD_TABLE) {
@@ -2964,6 +2941,8 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
        return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
      }
    }
+    tscDebug("0x%"PRIx64 " %s retrieve tableMeta from cache, numOfCols:%d, numOfTags:%d", pSql->self, name, pMeta->tableInfo.numOfColumns, pMeta->tableInfo.numOfTags);
    return TSDB_CODE_SUCCESS;
  }

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -892,7 +892,9 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
    return TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
  }
-  pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+  char* sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+  if(sqlstr == NULL && pSql->sqlstr) free(pSql->sqlstr);
+  pSql->sqlstr = sqlstr;
  if (pSql->sqlstr == NULL) {
    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
    tfree(pSql);

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -15,8 +15,9 @@
 #define _GNU_SOURCE
 #include "os.h"
 #include "texpr.h"
+#include "tsched.h"
 #include "qTsbuf.h"
 #include "tcompare.h"
 #include "tscLog.h"
@@ -2038,17 +2039,14 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
  tscAsyncResultOnError(pSql);
 }
-static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
+void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
  assert(numOfSubs <= pSql->subState.numOfSub && numOfSubs >= 0);
  for(int32_t i = 0; i < numOfSubs; ++i) {
    SSqlObj* pSub = pSql->pSubs[i];
    assert(pSub != NULL);
-    SRetrieveSupport* pSupport = pSub->param;
+    tscFreeRetrieveSup(pSub);
-    tfree(pSupport->localBuffer);
-    tfree(pSupport);
    taos_free_result(pSub);
  }
@@ -2406,6 +2404,10 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
        } else {
          SSchema ss = {.type = (uint8_t)pCol->info.type, .bytes = pCol->info.bytes, .colId = (int16_t)pCol->columnIndex};
          tscColumnListInsert(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid, &ss);
+          int32_t ti = tscColumnExists(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid);
+          assert(ti >= 0);
+          SColumn* x = taosArrayGetP(pNewQueryInfo->colList, ti);
+          tscColumnCopy(x, pCol);
        }
      }
    }
@@ -2442,7 +2444,11 @@ static void doSendQueryReqs(SSchedMsg* pSchedMsg) {
  SSqlObj* pSql = pSchedMsg->ahandle;
  SPair* p = pSchedMsg->msg;
-  for(int32_t i = p->first; i < p->second; ++i) {
+  for (int32_t i = p->first; i < p->second; ++i) {
+   if (i >= pSql->subState.numOfSub) {
+      tfree(p);
+      return;
+    }
    SSqlObj* pSub = pSql->pSubs[i];
    SRetrieveSupport* pSupport = pSub->param;
@@ -2582,7 +2588,12 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
  int32_t numOfTasks = (pState->numOfSub + MAX_REQUEST_PER_TASK - 1)/MAX_REQUEST_PER_TASK;
  assert(numOfTasks >= 1);
-  int32_t num = (pState->numOfSub/numOfTasks) + 1;
+  int32_t num;
+  if (pState->numOfSub / numOfTasks == MAX_REQUEST_PER_TASK) {
+    num = MAX_REQUEST_PER_TASK;
+  } else {
+    num = pState->numOfSub / numOfTasks + 1;
+  }
  tscDebug("0x%"PRIx64 " query will be sent by %d threads", pSql->self, numOfTasks);
  for(int32_t j = 0; j < numOfTasks; ++j) {
@@ -2607,7 +2618,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
  return TSDB_CODE_SUCCESS;
 }
-static void tscFreeRetrieveSup(SSqlObj *pSql) {
+void tscFreeRetrieveSup(SSqlObj *pSql) {
  SRetrieveSupport *trsupport = pSql->param;
  void* p = atomic_val_compare_exchange_ptr(&pSql->param, trsupport, 0);
@@ -2738,7 +2749,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
      }
    } else {  // reach the maximum retry count, abort
      atomic_val_compare_exchange_32(&pParentSql->res.code, TSDB_CODE_SUCCESS, numOfRows);
-      tscError("0x%"PRIx64" sub:0x%"PRIx64" retrieve failed,code:%s,orderOfSub:%d failed.no more retry,set global code:%s", pParentSql->self, pSql->self,
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" retrieve failed, code:%s, orderOfSub:%d FAILED. no more retry, set global code:%s", pParentSql->self, pSql->self,
               tstrerror(numOfRows), subqueryIndex, tstrerror(pParentSql->res.code));
    }
  }
@@ -2765,27 +2776,43 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
  if (!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE)) {
    int32_t code = pParentSql->res.code;
-    if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && pParentSql->retry < pParentSql->maxRetry) {
+    SSqlObj *userSql = NULL;
-      // remove the cached tableMeta and vgroup id list, and then parse the sql again
+    if (pParentSql->param) {
-      tscResetSqlCmd( &pParentSql->cmd, true, pParentSql->self);
+      userSql = ((SRetrieveSupport*)pParentSql->param)->pParentSql;
+    }
+    if (userSql == NULL) {
+      userSql = pParentSql;
+    }
+    if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && userSql->retry < userSql->maxRetry) {
+      if (userSql != pParentSql) {
+        tscFreeRetrieveSup(pParentSql);
+      }
-      pParentSql->retry++;
+      tscFreeSubobj(userSql);      
-      pParentSql->res.code = TSDB_CODE_SUCCESS;
+      tfree(userSql->pSubs);
-      tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
-          tstrerror(code), pParentSql->retry);
-      code = tsParseSql(pParentSql, true);
+      userSql->res.code = TSDB_CODE_SUCCESS;
+      userSql->retry++;
+      tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", userSql->self,
+          tstrerror(code), userSql->retry);
+      tscResetSqlCmd(&userSql->cmd, true, userSql->self);
+      code = tsParseSql(userSql, true);
      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
        return;
      }
      if (code != TSDB_CODE_SUCCESS) {
-        pParentSql->res.code = code;
+        userSql->res.code = code;
-        tscAsyncResultOnError(pParentSql);
+        tscAsyncResultOnError(userSql);
        return;
      }
-      executeQuery(pParentSql, pQueryInfo);
+      pQueryInfo = tscGetQueryInfo(&userSql->cmd);
+      executeQuery(userSql, pQueryInfo);
    } else {
      (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.code);
    }
@@ -2855,7 +2882,6 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
      pParentSql->self, pState->numOfSub, pState->numOfRetrievedRows);
  SQueryInfo *pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
-  tscClearInterpInfo(pPQueryInfo);
  code = tscCreateGlobalMerger(trsupport->pExtMemBuffer, pState->numOfSub, pDesc, pPQueryInfo, &pParentSql->res.pMerger, pParentSql->self);
  pParentSql->res.code = code;
@@ -2970,7 +2996,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" retrieve numOfRows:%d totalNumOfRows:%" PRIu64 " from ep:%s, orderOfSub:%d",
        pParentSql->self, pSql->self, pRes->numOfRows, pState->numOfRetrievedRows, pSql->epSet.fqdn[pSql->epSet.inUse], idx);
-    if (num > tsMaxNumOfOrderedResults && /*tscIsProjectionQueryOnSTable(pQueryInfo, 0) &&*/ !(tscGetQueryInfo(&pParentSql->cmd)->distinct)) {
+    if (num > tsMaxNumOfOrderedResults && tscIsProjectionQueryOnSTable(pQueryInfo, 0) && !(tscGetQueryInfo(&pParentSql->cmd)->distinct)) {
      tscError("0x%"PRIx64" sub:0x%"PRIx64" num of OrderedRes is too many, max allowed:%" PRId32 " , current:%" PRId64,
               pParentSql->self, pSql->self, tsMaxNumOfOrderedResults, num);
      tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_SORTED_RES_TOO_MANY);

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -29,6 +29,7 @@
 #include "tsclient.h"
 #include "ttimer.h"
 #include "ttokendef.h"
+#include "httpInt.h"
 static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
@@ -403,6 +404,27 @@ bool tscGroupbyColumn(SQueryInfo* pQueryInfo) {
  return false;
 }
+int32_t tscGetTopBotQueryExprIndex(SQueryInfo* pQueryInfo) {
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
+  for (int32_t i = 0; i < numOfExprs; ++i) {
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+    if (pExpr == NULL) {
+      continue;
+    }
+    if (pExpr->base.functionId == TSDB_FUNC_TS) {
+      continue;
+    }
+    if (pExpr->base.functionId == TSDB_FUNC_TOP || pExpr->base.functionId == TSDB_FUNC_BOTTOM) {
+      return i;
+    }
+  }
+  return -1;
+}
 bool tscIsTopBotQuery(SQueryInfo* pQueryInfo) {
  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
@@ -659,8 +681,10 @@ static void setResRawPtrImpl(SSqlRes* pRes, SInternalField* pInfo, int32_t i, bo
  } else if (convertNchar && pInfo->field.type == TSDB_DATA_TYPE_NCHAR) {
    // convert unicode to native code in a temporary buffer extra one byte for terminated symbol
-    pRes->buffer[i] = realloc(pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
+    char* buffer = realloc(pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
+    if(buffer == NULL)
+       return ;
+    pRes->buffer[i] = buffer;
    // string terminated char for binary data
    memset(pRes->buffer[i], 0, pInfo->field.bytes * pRes->numOfRows);
@@ -1236,6 +1260,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
    }
    SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilters);
    pOutput->precision = pSqlObjList[0]->res.precision;
    SSchema* schema = NULL;
@@ -2096,6 +2121,22 @@ TAOS_FIELD tscCreateField(int8_t type, const char* name, int16_t bytes) {
  return f;
 }
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo) {
+  if (pQueryInfo->fieldsInfo.numOfOutput <= 0 || pQueryInfo->fieldsInfo.internalField == NULL) {
+    return 0;
+  }
+  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
+    SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
+    if (!pField->visible) {
+      return i;
+    }
+  }
+  return pQueryInfo->fieldsInfo.numOfOutput;
+}
 SInternalField* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField) {
  assert(pFieldInfo != NULL);
  pFieldInfo->numOfOutput++;
@@ -2419,6 +2460,19 @@ size_t tscNumOfExprs(SQueryInfo* pQueryInfo) {
  return taosArrayGetSize(pQueryInfo->exprList);
 }
+int32_t tscExprTopBottomIndex(SQueryInfo* pQueryInfo){
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
+  for(int32_t i = 0; i < numOfExprs; ++i) {
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+    if (pExpr == NULL)
+      continue;
+    if (pExpr->base.functionId == TSDB_FUNC_TOP || pExpr->base.functionId == TSDB_FUNC_BOTTOM) {
+      return i;
+    }
+  }
+  return -1;
+}
 // todo REFACTOR
 void tscExprAddParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes) {
  assert (pExpr != NULL || argument != NULL || bytes != 0);
@@ -3128,6 +3182,7 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
  pQueryInfo->slimit.offset  = 0;
  pQueryInfo->pUpstream      = taosArrayInit(4, POINTER_BYTES);
  pQueryInfo->window         = TSWINDOW_INITIALIZER;
+  pQueryInfo->multigroupResult = true;
 }
 int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
@@ -3139,7 +3194,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
  }
  tscInitQueryInfo(pQueryInfo);
  pQueryInfo->msg = pCmd->payload;  // pointer to the parent error message buffer
  if (pCmd->pQueryInfo == NULL) {
@@ -3188,6 +3242,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
  taosArrayDestroy(pQueryInfo->pUpstream);
  pQueryInfo->pUpstream = NULL;
+  pQueryInfo->bufLen = 0;
 }
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@@ -3222,6 +3277,7 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
  pQueryInfo->window         = pSrc->window;
  pQueryInfo->sessionWindow  = pSrc->sessionWindow;
  pQueryInfo->pTableMetaInfo = NULL;
+  pQueryInfo->multigroupResult = pSrc->multigroupResult;
  pQueryInfo->bufLen         = pSrc->bufLen;
  pQueryInfo->orderProjectQuery = pSrc->orderProjectQuery;
@@ -3612,17 +3668,18 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
  pNewQueryInfo->limit        = pQueryInfo->limit;
  pNewQueryInfo->slimit       = pQueryInfo->slimit;
  pNewQueryInfo->order        = pQueryInfo->order;
-  pNewQueryInfo->vgroupLimit = pQueryInfo->vgroupLimit;
  pNewQueryInfo->tsBuf        = NULL;
  pNewQueryInfo->fillType     = pQueryInfo->fillType;
  pNewQueryInfo->fillVal      = NULL;
-  pNewQueryInfo->numOfFillVal = 0;
  pNewQueryInfo->clauseLimit  = pQueryInfo->clauseLimit;
  pNewQueryInfo->prjOffset    = pQueryInfo->prjOffset;
+  pNewQueryInfo->numOfFillVal = 0;
  pNewQueryInfo->numOfTables  = 0;
  pNewQueryInfo->pTableMetaInfo = NULL;
  pNewQueryInfo->bufLen       = pQueryInfo->bufLen;
+  pNewQueryInfo->vgroupLimit  = pQueryInfo->vgroupLimit;
  pNewQueryInfo->distinct     =  pQueryInfo->distinct;
+  pNewQueryInfo->multigroupResult = pQueryInfo->multigroupResult;
  pNewQueryInfo->buf          = malloc(pQueryInfo->bufLen);
  if (pNewQueryInfo->buf == NULL) {
@@ -3840,8 +3897,7 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
    int32_t index = ps->subqueryIndex;
    bool ret = subAndCheckDone(pSql, pParentSql, index);
-    tfree(ps);
+    tscFreeRetrieveSup(pSql);
-    pSql->param = NULL;
    if (!ret) {
      tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, index);
@@ -3850,7 +3906,15 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
    // todo refactor
    tscDebug("0x%"PRIx64" all subquery response received, retry", pParentSql->self);
-    tscResetSqlCmd(&pParentSql->cmd, true, pParentSql->self);
+    if (code && !((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && pParentSql->retry < pParentSql->maxRetry)) {
+      pParentSql->res.code = code;
+      tscAsyncResultOnError(pParentSql);
+      return;
+    }
+    tscFreeSubobj(pParentSql);
+    tfree(pParentSql->pSubs);
    pParentSql->res.code = TSDB_CODE_SUCCESS;
    pParentSql->retry++;
@@ -3858,6 +3922,9 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
    tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
             tstrerror(code), pParentSql->retry);
+    tscResetSqlCmd(&pParentSql->cmd, true, pParentSql->self);
    code = tsParseSql(pParentSql, true);
    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
      return;
@@ -3892,9 +3959,11 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
  }
  if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // nest query. do execute it firstly
+    assert(pSql->subState.numOfSub == 0);
    pSql->subState.numOfSub = (int32_t) taosArrayGetSize(pQueryInfo->pUpstream);
+    assert(pSql->pSubs == NULL);
    pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
+    assert(pSql->subState.states == NULL);
    pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
    code = pthread_mutex_init(&pSql->subState.mutex, NULL);
@@ -3919,7 +3988,11 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
      pNew->signature = pNew;
      pNew->sqlstr    = strdup(pSql->sqlstr);
      pNew->fp        = tscSubqueryCompleteCallback;
+      pNew->fetchFp   = tscSubqueryCompleteCallback;
      pNew->maxRetry  = pSql->maxRetry;
+      pNew->cmd.resColumnId = TSDB_RES_COL_ID;
      tsem_init(&pNew->rspSem, 0, 0);
      SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));  // todo use object id
@@ -4096,6 +4169,31 @@ int32_t tscInvalidOperationMsg(char* msg, const char* additionalInfo, const char
  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql) {
+  const char* msgFormat1 = "%s:%s";
+  const char* msgFormat2 = "%s:\'%s\' (%s)";
+  const char* msgFormat3 = "%s:\'%s\'";
+  const int32_t BACKWARD_CHAR_STEP = 0;
+  if (sql == NULL) {
+    assert(errMsg != NULL);
+    sprintf(dstBuffer, msgFormat1, tstrerror(code), errMsg);
+    return code;
+  }
+  char buf[64] = {0};  // only extract part of sql string
+  strncpy(buf, (sql - BACKWARD_CHAR_STEP), tListLen(buf) - 1);
+  if (errMsg != NULL) {
+    sprintf(dstBuffer, msgFormat2, tstrerror(code), buf, errMsg);
+  } else {
+    sprintf(dstBuffer, msgFormat3, tstrerror(code), buf);  // no additional information for invalid sql error
+  }
+  return code;
+}
 bool tscHasReachLimitation(SQueryInfo* pQueryInfo, SSqlRes* pRes) {
  assert(pQueryInfo != NULL && pQueryInfo->clauseLimit != 0);
  return (pQueryInfo->clauseLimit > 0 && pRes->numOfClauseTotal >= pQueryInfo->clauseLimit);
@@ -4452,21 +4550,27 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
  assert(*ppChild != NULL);
  STableMeta* p      = *ppSTable;
  STableMeta* pChild = *ppChild;
  size_t sz = (p != NULL) ? tscGetTableMetaSize(p) : 0; //ppSTableBuf actually capacity may larger than sz, dont care
  if (p != NULL && sz != 0) {
    memset((char *)p, 0, sz);
  }
-  taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz);
+  if (NULL == taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz)) {
+    tfree(p);
+  } else {
    *ppSTable = p;
+  }
  // tableMeta exists, build child table meta according to the super table meta
  // the uid need to be checked in addition to the general name of the super table.
  if (p && p->id.uid > 0 && pChild->suid == p->id.uid) {
    int32_t totalBytes    = (p->tableInfo.numOfColumns + p->tableInfo.numOfTags) * sizeof(SSchema);
    int32_t tableMetaSize =  sizeof(STableMeta)  + totalBytes;
    if (*tableMetaCapacity < tableMetaSize) {
-      pChild = realloc(pChild, tableMetaSize); 
+      STableMeta* pChild1 = realloc(pChild, tableMetaSize);
+      if(pChild1 == NULL) return -1;
+      pChild = pChild1; 
      *tableMetaCapacity = (size_t)tableMetaSize;
    }
@@ -4736,6 +4840,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  pQueryAttr->distinct          = pQueryInfo->distinct;
  pQueryAttr->sw                = pQueryInfo->sessionWindow;
  pQueryAttr->stateWindow       = pQueryInfo->stateWindow;
+  pQueryAttr->multigroupResult  = pQueryInfo->multigroupResult;
  pQueryAttr->numOfCols         = numOfCols;
  pQueryAttr->numOfOutput       = numOfOutput;
@@ -5008,3 +5113,31 @@ void tscRemoveCachedTableMeta(STableMetaInfo* pTableMetaInfo, uint64_t id) {
  taosHashRemove(tscTableMetaMap, fname, len);
  tscDebug("0x%"PRIx64" remove table meta %s, numOfRemain:%d", id, fname, (int32_t) taosHashGetSize(tscTableMetaMap));
 }
+char* cloneCurrentDBName(SSqlObj* pSql) {
+  char        *p = NULL;
+  HttpContext *pCtx = NULL;
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
+  STscObj *pTscObj = pSql->pTscObj;
+  switch (pTscObj->from) {
+  case TAOS_REQ_FROM_HTTP:
+    pCtx = pSql->param;
+    if (pCtx && pCtx->db[0] != '\0') {
+      char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN] = {0};
+      int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
+      assert(len <= sizeof(db));
+      p = strdup(db);
+    }
+    break;
+  default:
+    break;
+  }
+  if (p == NULL) {
+    p = strdup(pSql->pTscObj->db);
+  }
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
+  return p;
+}
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -547,8 +547,9 @@ SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder);
 static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, void *value) {
  if (pBuilder->nCols >= pBuilder->tCols) {
    pBuilder->tCols *= 2;
-    pBuilder->pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
+    SColIdx* pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
-    if (pBuilder->pColIdx == NULL) return -1;
+    if (pColIdx == NULL) return -1;
+    pBuilder->pColIdx = pColIdx;
  }
  pBuilder->pColIdx[pBuilder->nCols].colId = colId;
@@ -561,8 +562,9 @@ static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId,
    while (tlen > pBuilder->alloc - pBuilder->size) {
      pBuilder->alloc *= 2;
    }
-    pBuilder->buf = realloc(pBuilder->buf, pBuilder->alloc);
+    void* buf = realloc(pBuilder->buf, pBuilder->alloc);
-    if (pBuilder->buf == NULL) return -1;
+    if (buf == NULL) return -1;
+    pBuilder->buf = buf;
  }
  memcpy(POINTER_SHIFT(pBuilder->buf, pBuilder->size), value, tlen);

--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -131,6 +131,7 @@ extern int32_t  tsHttpMaxThreads;
 extern int8_t   tsHttpEnableCompress;
 extern int8_t   tsHttpEnableRecordSql;
 extern int8_t   tsTelegrafUseFieldNum;
+extern int8_t   tsHttpDbNameMandatory;
 // mqtt
 extern int8_t tsEnableMqttModule;
@@ -164,6 +165,7 @@ extern char    tsDataDir[];
 extern char    tsLogDir[];
 extern char    tsScriptDir[];
 extern int64_t tsTickPerDay[3];
+extern int32_t tsTopicBianryLen;
 // system info
 extern char    tsOsName[];

--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -138,8 +138,9 @@ int tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId, int1
  if (pBuilder->nCols >= pBuilder->tCols) {
    pBuilder->tCols *= 2;
-    pBuilder->columns = (STColumn *)realloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
+    STColumn* columns = (STColumn *)realloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
-    if (pBuilder->columns == NULL) return -1;
+    if (columns == NULL) return -1;
+    pBuilder->columns = columns;
  }
  STColumn *pCol = &(pBuilder->columns[pBuilder->nCols]);

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -84,8 +84,9 @@ int32_t tsCompressColData = -1;
 // client
 int32_t tsMaxSQLStringLen = TSDB_MAX_ALLOWED_SQL_LEN;
-int32_t tsMaxWildCardsLen = TSDB_PATTERN_STRING_MAX_LEN;
+int32_t tsMaxWildCardsLen = TSDB_PATTERN_STRING_DEFAULT_LEN;
-int32_t tsMaxRegexStringLen = TSDB_REGEX_STRING_MAX_LEN;
+int32_t tsMaxRegexStringLen = TSDB_REGEX_STRING_DEFAULT_LEN;
 int8_t  tsTscEnableRecordSql = 0;
 // the maximum number of results for projection query on super table that are returned from
@@ -153,7 +154,6 @@ int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;
 int32_t tsTsdbMetaCompactRatio = TSDB_META_COMPACT_RATIO;
 // tsdb config 
 // For backward compatibility
 bool tsdbForceKeepFile = false;
@@ -177,6 +177,7 @@ int32_t  tsHttpMaxThreads = 2;
 int8_t   tsHttpEnableCompress = 1;
 int8_t   tsHttpEnableRecordSql = 0;
 int8_t   tsTelegrafUseFieldNum = 0;
+int8_t   tsHttpDbNameMandatory = 0;
 // mqtt
 int8_t tsEnableMqttModule = 0;  // not finished yet, not started it by default
@@ -211,6 +212,7 @@ char   tsScriptDir[PATH_MAX] = {0};
 char   tsTempDir[PATH_MAX] = "/tmp/";
 int32_t  tsDiskCfgNum = 0;
+int32_t tsTopicBianryLen = 16000;
 #ifndef _STORAGE
 SDiskCfg tsDiskCfg[1];
@@ -571,7 +573,6 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
  cfg.option = "numOfMnodes";
  cfg.ptr = &tsNumOfMnodes;
  cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -1239,6 +1240,16 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
+  cfg.option = "topicBianryLen";
+  cfg.ptr = &tsTopicBianryLen;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+  cfg.minValue = 16;
+  cfg.maxValue = 16000;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
  cfg.option = "httpEnableRecordSql";
  cfg.ptr = &tsHttpEnableRecordSql;
  cfg.valType = TAOS_CFG_VTYPE_INT8;
@@ -1279,6 +1290,16 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
+  cfg.option = "httpDbNameMandatory";
+  cfg.ptr = &tsHttpDbNameMandatory;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
  // debug flag
  cfg.option = "numOfLogLines";
  cfg.ptr = &tsNumOfLogLines;

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

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
@@ -40,13 +40,13 @@ public class TSDBError {
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_SUBSCRIBE_FAILED, "failed to create subscription");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING, "Unsupported encoding");
-        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database");
+        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database, please see taoslog for more details");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "JNI connection is NULL");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL, "JNI result set is NULL");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0, "invalid num of fields");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_SQL_NULL, "empty sql string");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_FETCH_END, "fetch to the end of resultSet");
-        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed");
+        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed, please see taoslog for more details");
    }
    public static SQLException createSQLException(int errorCode) {

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
@@ -278,25 +278,20 @@ public class TSDBJNIConnector {
    private native int validateCreateTableSqlImp(long connection, byte[] sqlBytes);
    public long prepareStmt(String sql) throws SQLException {
-        long stmt;
+        long stmt = prepareStmtImp(sql.getBytes(), this.taos);
-        try {
-            stmt = prepareStmtImp(sql.getBytes(), this.taos);
-        } catch (Exception e) {
-            e.printStackTrace();
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING);
-        }
        if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "connection already closed");
        }
        if (stmt == TSDBConstants.JNI_SQL_NULL) {
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_SQL_NULL);
        }
        if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY);
        }
+        if (stmt == TSDBConstants.JNI_TDENGINE_ERROR) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR);
+        }
        return stmt;
    }
@@ -313,8 +308,7 @@ public class TSDBJNIConnector {
    private native int setBindTableNameImp(long stmt, String name, long conn);
    public void setBindTableNameAndTags(long stmt, String tableName, int numOfTags, ByteBuffer tags, ByteBuffer typeList, ByteBuffer lengthList, ByteBuffer nullList) throws SQLException {
-        int code = setTableNameTagsImp(stmt, tableName, numOfTags, tags.array(), typeList.array(), lengthList.array(),
+        int code = setTableNameTagsImp(stmt, tableName, numOfTags, tags.array(), typeList.array(), lengthList.array(), nullList.array(), this.taos);
-                nullList.array(), this.taos);
        if (code != TSDBConstants.JNI_SUCCESS) {
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to bind table name and corresponding tags");
        }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
@@ -18,7 +18,7 @@ public class RestfulConnection extends AbstractConnection {
    private final String url;
    private final String database;
    private final String token;
-    /******************************************************/
    private boolean isClosed;
    private final DatabaseMetaData metadata;

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
@@ -88,17 +88,24 @@ public class RestfulStatement extends AbstractStatement {
    }
    private String getUrl() throws SQLException {
+        String dbname = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_DBNAME);
+        if (dbname == null || dbname.trim().isEmpty()) {
+            dbname = "";
+        } else {
+            dbname = "/" + dbname.toLowerCase();
+        }
        TimestampFormat timestampFormat = TimestampFormat.valueOf(conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT).trim().toUpperCase());
        String url;
        switch (timestampFormat) {
            case TIMESTAMP:
-                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt";
+                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt" + dbname;
                break;
            case UTC:
-                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc";
+                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc" + dbname;
                break;
            default:
-                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
+                url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql" + dbname;
        }
        return url;
    }

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
+package com.taosdata.jdbc.cases;
+import org.junit.Before;
+import org.junit.Test;
+import java.sql.*;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+public class MultiConnectionWithDifferentDbTest {
+    private static String host = "127.0.0.1";
+    private static String db1 = "db1";
+    private static String db2 = "db2";
+    private long ts;
+    @Test
+    public void test() {
+        List<Thread> threads = IntStream.range(1, 3).mapToObj(i -> new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for (int j = 0; j < 10; j++) {
+                    queryDb();
+                    try {
+                        TimeUnit.SECONDS.sleep(1);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+            private void queryDb() {
+                String url = "jdbc:TAOS-RS://" + host + ":6041/db" + i + "?user=root&password=taosdata";
+                try (Connection connection = DriverManager.getConnection(url)) {
+                    Statement stmt = connection.createStatement();
+                    ResultSet rs = stmt.executeQuery("select * from weather");
+                    assertNotNull(rs);
+                    rs.next();
+                    long actual = rs.getTimestamp("ts").getTime();
+                    assertEquals(ts, actual);
+                    int f1 = rs.getInt("f1");
+                    assertEquals(i, f1);
+                    String loc = i == 1 ? "beijing" : "shanghai";
+                    String loc_actual = rs.getString("loc");
+                    assertEquals(loc, loc_actual);
+                    stmt.close();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }, "thread-" + i)).collect(Collectors.toList());
+        threads.forEach(Thread::start);
+        for (Thread t : threads) {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+    @Before
+    public void before() {
+        ts = System.currentTimeMillis();
+        try {
+            Connection conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
+            Statement stmt = conn.createStatement();
+            stmt.execute("drop database if exists " + db1);
+            stmt.execute("create database if not exists " + db1);
+            stmt.execute("use " + db1);
+            stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+            stmt.execute("insert into t1 using weather tags('beijing') values(" + ts + ", 1)");
+            stmt.execute("drop database if exists " + db2);
+            stmt.execute("create database if not exists " + db2);
+            stmt.execute("use " + db2);
+            stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+            stmt.execute("insert into t1 using weather tags('shanghai') values(" + ts + ", 2)");
+            conn.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java
+package com.taosdata.jdbc.cases;
+import org.junit.Before;
+import org.junit.Test;
+import java.sql.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+public class UseNowInsertTimestampTest {
+    String url = "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata";
+    @Test
+    public void millisec() {
+        try (Connection conn = DriverManager.getConnection(url)) {
+            Statement stmt = conn.createStatement();
+            stmt.execute("drop database if exists test");
+            stmt.execute("create database if not exists test precision 'ms'");
+            stmt.execute("use test");
+            stmt.execute("create table weather(ts timestamp, f1 int)");
+            stmt.execute("insert into weather values(now, 1)");
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            rs.next();
+            Timestamp ts = rs.getTimestamp("ts");
+            assertEquals(13, Long.toString(ts.getTime()).length());
+            int nanos = ts.getNanos();
+            assertEquals(0, nanos % 1000_000);
+            stmt.execute("drop database if exists test");
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @Test
+    public void microsec() {
+        try (Connection conn = DriverManager.getConnection(url)) {
+            Statement stmt = conn.createStatement();
+            stmt.execute("drop database if exists test");
+            stmt.execute("create database if not exists test precision 'us'");
+            stmt.execute("use test");
+            stmt.execute("create table weather(ts timestamp, f1 int)");
+            stmt.execute("insert into weather values(now, 1)");
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            rs.next();
+            Timestamp ts = rs.getTimestamp("ts");
+            int nanos = ts.getNanos();
+            assertEquals(0, nanos % 1000);
+            stmt.execute("drop database if exists test");
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @Test
+    public void nanosec() {
+        try (Connection conn = DriverManager.getConnection(url)) {
+            Statement stmt = conn.createStatement();
+            stmt.execute("drop database if exists test");
+            stmt.execute("create database if not exists test precision 'ns'");
+            stmt.execute("use test");
+            stmt.execute("create table weather(ts timestamp, f1 int)");
+            stmt.execute("insert into weather values(now, 1)");
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            rs.next();
+            Timestamp ts = rs.getTimestamp("ts");
+            int nanos = ts.getNanos();
+            assertTrue(nanos % 1000 != 0);
+            stmt.execute("drop database if exists test");
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
+package com.taosdata.jdbc.rs;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import java.sql.*;
+import static org.junit.Assert.*;
+public class DatabaseSpecifiedTest {
+    private static String host = "127.0.0.1";
+    private static String dbname = "test_db_spec";
+    private Connection connection;
+    private long ts;
+    @Test
+    public void test() throws SQLException {
+        // when
+        connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/" + dbname + "?user=root&password=taosdata");
+        try (Statement stmt = connection.createStatement();) {
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            //then
+            assertNotNull(rs);
+            rs.next();
+            long now = rs.getTimestamp("ts").getTime();
+            assertEquals(ts, now);
+            int f1 = rs.getInt(2);
+            assertEquals(1, f1);
+            String loc = rs.getString("loc");
+            assertEquals("beijing", loc);
+        }
+        connection.close();
+    }
+    @Before
+    public void before() {
+        ts = System.currentTimeMillis();
+        try {
+            Connection connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
+            Statement stmt = connection.createStatement();
+            stmt.execute("drop database if exists " + dbname);
+            stmt.execute("create database if not exists " + dbname);
+            stmt.execute("use " + dbname);
+            stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+            stmt.execute("insert into t1 using weather tags('beijing') values( " + ts + ", 1)");
+            stmt.close();
+            connection.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @After
+    public void after() {
+        try {
+            if (connection != null)
+                connection.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
--- a/src/connector/python/examples/demo.py
+++ b/src/connector/python/examples/demo.py
@@ -2,7 +2,7 @@ import taos
 conn = taos.connect(host='127.0.0.1',
                    user='root',
-                    passworkd='taodata',
+                    password='taosdata',
                    database='log')
 cursor = conn.cursor()

--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
@@ -49,7 +49,7 @@ def _load_taos():
    try:
        return load_func[platform.system()]()
    except:
-        sys.exit("unsupported platform to TDengine connector")
+        raise InterfaceError('unsupported platform or failed to load taos client library')
 _libtaos = _load_taos()

--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/kit/shell/src/shellCheck.c
+++ b/src/kit/shell/src/shellCheck.c
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -254,9 +254,13 @@ int32_t shellRunCommand(TAOS* con, char* command) {
    }
    if (c == '\\') {
+      if (quote != 0 && (*command == '_' || *command == '\\')) {
+        //DO nothing 
+      } else {
        esc = true;
        continue;
      }
+    }
    if (quote == c) {
      quote = 0;

--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/kit/taospack/taospack.c
+++ b/src/kit/taospack/taospack.c
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/os/src/detail/osMemory.c
+++ b/src/os/src/detail/osMemory.c
--- a/src/os/src/linux/linuxEnv.c
+++ b/src/os/src/linux/linuxEnv.c
--- a/src/os/src/windows/wGetline.c
+++ b/src/os/src/windows/wGetline.c
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
--- a/src/plugins/http/inc/httpRestHandle.h
+++ b/src/plugins/http/inc/httpRestHandle.h
--- a/src/plugins/http/src/httpRestHandle.c
+++ b/src/plugins/http/src/httpRestHandle.c
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
--- a/src/plugins/monitor/src/monMain.c
+++ b/src/plugins/monitor/src/monMain.c
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
--- a/src/query/inc/qExtbuffer.h
+++ b/src/query/inc/qExtbuffer.h
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
--- a/src/query/inc/qTableMeta.h
+++ b/src/query/inc/qTableMeta.h
--- a/src/query/inc/queryLog.h
+++ b/src/query/inc/queryLog.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/tsdb/inc/tsdbFS.h
+++ b/src/tsdb/inc/tsdbFS.h
--- a/src/tsdb/src/tsdbFS.c
+++ b/src/tsdb/src/tsdbFS.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/util/inc/tcompare.h
+++ b/src/util/inc/tcompare.h
--- a/src/util/inc/tutil.h
+++ b/src/util/inc/tutil.h
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
--- a/src/util/tests/skiplistTest.cpp
+++ b/src/util/tests/skiplistTest.cpp
--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
--- a/tests/examples/c/schemaless.c
+++ b/tests/examples/c/schemaless.c
--- a/tests/http/restful/http_create_db.c
+++ b/tests/http/restful/http_create_db.c
--- a/tests/http/restful/http_create_tb.c
+++ b/tests/http/restful/http_create_tb.c
--- a/tests/http/restful/http_drop_db.c
+++ b/tests/http/restful/http_drop_db.c
--- a/tests/http/restful/http_insert_tb.c
+++ b/tests/http/restful/http_insert_tb.c
--- a/tests/http/restful/http_query_tb.c
+++ b/tests/http/restful/http_query_tb.c
--- a/tests/http/restful/http_use_db.c
+++ b/tests/http/restful/http_use_db.c
--- a/tests/nettest/FQDNnettest.sh
+++ b/tests/nettest/FQDNnettest.sh
--- a/tests/nettest/TCPUDP.sh
+++ b/tests/nettest/TCPUDP.sh
--- a/tests/nettest/tcpudp.sh
+++ b/tests/nettest/tcpudp.sh
--- a/tests/pytest/alter/alter_table.py
+++ b/tests/pytest/alter/alter_table.py
--- a/tests/pytest/concurrent_inquiry.py
+++ b/tests/pytest/concurrent_inquiry.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/functions/function_bottom.py
+++ b/tests/pytest/functions/function_bottom.py
--- a/tests/pytest/functions/function_derivative.py
+++ b/tests/pytest/functions/function_derivative.py
--- a/tests/pytest/functions/function_diff.py
+++ b/tests/pytest/functions/function_diff.py
--- a/tests/pytest/functions/function_interp.py
+++ b/tests/pytest/functions/function_interp.py
--- a/tests/pytest/functions/function_top.py
+++ b/tests/pytest/functions/function_top.py
--- a/tests/pytest/functions/queryTestCases.py
+++ b/tests/pytest/functions/queryTestCases.py
--- a/tests/pytest/insert/insertFromCSVPerformance.py
+++ b/tests/pytest/insert/insertFromCSVPerformance.py
--- a/tests/pytest/query/last_row_cache.py
+++ b/tests/pytest/query/last_row_cache.py
--- a/tests/pytest/query/nestedQuery/queryWithOrderLimit.py
+++ b/tests/pytest/query/nestedQuery/queryWithOrderLimit.py
--- a/tests/pytest/query/query.py
+++ b/tests/pytest/query/query.py
--- a/tests/pytest/query/queryDiffColsOr.py
+++ b/tests/pytest/query/queryDiffColsOr.py
--- a/tests/pytest/query/queryError.py
+++ b/tests/pytest/query/queryError.py
--- a/tests/pytest/query/queryLike.py
+++ b/tests/pytest/query/queryLike.py
--- a/tests/pytest/query/queryPerformance.py
+++ b/tests/pytest/query/queryPerformance.py
--- a/tests/pytest/query/queryTbnameUpperLower.py
+++ b/tests/pytest/query/queryTbnameUpperLower.py
--- a/tests/pytest/query/tbname.py
+++ b/tests/pytest/query/tbname.py
--- a/tests/pytest/restful/restful_bind_db1.py
+++ b/tests/pytest/restful/restful_bind_db1.py
--- a/tests/pytest/restful/restful_bind_db2.py
+++ b/tests/pytest/restful/restful_bind_db2.py
--- a/tests/pytest/tools/schemalessInsertPerformance.py
+++ b/tests/pytest/tools/schemalessInsertPerformance.py
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.py
--- a/tests/pytest/util/dnodes-default.py
+++ b/tests/pytest/util/dnodes-default.py
--- a/tests/pytest/util/dnodes-no-random-fail.py
+++ b/tests/pytest/util/dnodes-no-random-fail.py
--- a/tests/pytest/util/dnodes-random-fail.py
+++ b/tests/pytest/util/dnodes-random-fail.py
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
--- a/tests/script/api/makefile
+++ b/tests/script/api/makefile
--- a/tests/script/api/stmt_function.c
+++ b/tests/script/api/stmt_function.c
--- a/tests/script/fullGeneralSuite.sim
+++ b/tests/script/fullGeneralSuite.sim
--- a/tests/script/general/http/restful_dbname.sim
+++ b/tests/script/general/http/restful_dbname.sim
--- a/tests/script/general/parser/columnValue_float.sim
+++ b/tests/script/general/parser/columnValue_float.sim
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
--- a/tests/script/general/parser/interp.sim
+++ b/tests/script/general/parser/interp.sim
--- a/tests/script/general/parser/interp_test.sim
+++ b/tests/script/general/parser/interp_test.sim
--- a/tests/script/general/parser/like.sim
+++ b/tests/script/general/parser/like.sim
--- a/tests/script/general/parser/limit.sim
+++ b/tests/script/general/parser/limit.sim
--- a/tests/script/general/parser/limit_tb.sim
+++ b/tests/script/general/parser/limit_tb.sim
--- a/tests/script/general/parser/tbnameIn_query.sim
+++ b/tests/script/general/parser/tbnameIn_query.sim
--- a/tests/script/http/httpTest.c
+++ b/tests/script/http/httpTest.c
--- a/tests/script/http/makefile
+++ b/tests/script/http/makefile
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt