[TD-6308]<fix> partial loaded table meta cause unexpected result

00b76338 · dengyihao · afc788f0 · 72f38c33 · 00b76338 · 00b76338
66 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/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.1")
 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/TSZ @ ceda5bf9
+++ b/TSZ @ ceda5bf9
-Subproject commit 0ca5b15a8eac40327dd737be52c926fa5675712c
+Subproject commit ceda5bf9fcd7836509ac97dcc0056b3f1dd48cc5
--- 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,25 +48,25 @@ 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>
+taos> 
 ```
 TDengine 终端成功连接服务端，打印出了欢迎消息和版本信息。如果失败，会有错误信息打印出来。
@@ -78,45 +79,74 @@ 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>
+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 |	   ···
 ```
@@ -136,10 +166,10 @@ $ taos> use test;
 Database changed.
 $ taos> show stables;
-       name              |      created_time       | columns |  tags  |   tables    |
+              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/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中指定表、超级表的数据库名称。例如：
+```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,27 @@ 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连接数据库前，需要具备以下条件：
-由于 TDengine 的应用驱动是使用C语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。
+1. Linux或Windows操作系统
+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,39 +109,22 @@ 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
-### 示例程序
+可以通过下载TDengine的源码，自己编译最新版本的java connector
+```shell
-示例程序源码位于install_directory/examples/JDBC，有如下目录：
+git clone https://github.com/taosdata/TDengine.git
+cd TDengine/src/connector/jdbc
-JDBCDemo                JDBC示例源程序
+mvn clean package -Dmaven.test.skip=true
-JDBCConnectorChecker    JDBC安装校验源程序及jar包
-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连接器的使用
 ### 获取连接
 #### 指定URL获取连接
 通过指定URL获取连接，如下所示：
 ```java
@@ -159,23 +132,19 @@ Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
 String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
 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";
 Connection conn = DriverManager.getConnection(jdbcUrl);
 ```
 以上示例，使用了 JDBC-JNI 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
 **注意**：使用 JDBC-JNI 的 driver，taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库（Linux 下是 libtaos.so；Windows 下是 taos.dll）。
@@ -194,6 +163,9 @@ url中的配置参数如下：
 * 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,11 +194,13 @@ properties 中的配置参数如下：
 * 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。
 #### 使用客户端配置文件建立连接
 当使用 JDBC-JNI 连接 TDengine 集群时，可以使用客户端配置文件，在客户端配置文件中指定集群的 firstEp、secondEp参数。如下所示：
 1. 在 Java 应用中不指定 hostname 和 port
 ```java
@@ -243,7 +217,6 @@ public Connection getConn() throws Exception{
 ```
 2. 在配置文件中指定 firstEp 和 secondEp
 ```
 # first fully qualified domain name (FQDN) for TDengine system
 firstEp               cluster_node1:6030
@@ -424,9 +397,9 @@ public void setNString(int columnIndex, ArrayList<String> list, int size) throws
 ```
 其中 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);
@@ -440,7 +413,7 @@ TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from met
 如上面的例子将使用 SQL 语句 `select * from meters` 创建一个名为 `topic` 的订阅，如果这个订阅已经存在，将继续之前的查询进度，而不是从头开始消费所有的数据。
-#### 消费数据
+### 消费数据
 ```java
 int total = 0;
@@ -458,7 +431,7 @@ while(true) {
 `consume` 方法返回一个结果集，其中包含从上次 `consume` 到目前为止的所有新数据。请务必按需选择合理的调用 `consume` 的频率（如例子中的 `Thread.sleep(1000)`），否则会给服务端造成不必要的压力。
-#### 关闭订阅
+### 关闭订阅
 ```java
 sub.close(true);
@@ -466,7 +439,7 @@ sub.close(true);
 `close` 方法关闭一个订阅。如果其参数为 `true` 表示保留订阅进度信息，后续可以创建同名订阅继续消费数据；如为 `false` 则不保留订阅进度。
-### 关闭资源
+## 关闭资源
 ```java
 resultSet.close();
@@ -478,19 +451,8 @@ 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 {
@@ -522,19 +484,8 @@ 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 {
@@ -580,6 +531,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
@@ -966,13 +966,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

--- a/documentation20/en/08.connector/01.java/docs.md
+++ b/documentation20/en/08.connector/01.java/docs.md
@@ -203,7 +203,7 @@ The configuration parameters in properties are as follows:
 * TSDBDriver.PROPERTY_KEY_LOCALE: client locale. The default value is the current system locale.
 * TSDBDriver.PROPERTY_KEY_TIME_ZONE: timezone used by the client. The default value is the current timezone of the system.
 * TSDBDriver.PROPERTY_KEY_BATCH_LOAD: only valid for JDBC-JNI. True if batch ResultSet fetching is enabled; false if row-by-row ResultSet fetching is enabled. Default value is flase.
-* TSDBDriver.PROPERTY_KEY_BATCH_LOAD: only valid for JDBC-RESTful. 'TIMESTAMP' if you want to get a long value in a ResultSet; 'UTC' if you want to get a string in UTC date-time format in a ResultSet; 'STRING' if you want to get a local date-time format string in ResultSet. Default value is 'STRING'.
+* TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT: only valid for JDBC-RESTful. 'TIMESTAMP' if you want to get a long value in a ResultSet; 'UTC' if you want to get a string in UTC date-time format in a ResultSet; 'STRING' if you want to get a local date-time format string in ResultSet. Default value is 'STRING'.
 * TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE: true if you want to continue executing the rest of the SQL when error happens during execute the executeBatch method in Statement; false, false if the remaining SQL statements are not executed. Default value is false.
 #### Establishing a connection with configuration file
@@ -317,14 +317,17 @@ Since version 2.1.2.0, TDengine's JDBC-JNI implementation has significantly impr
 Statement stmt = conn.createStatement();
 Random r = new Random();
+// In the INSERT statement, the VALUES clause allows you to specify a specific column; If automatic table creation is adopted, the TAGS clause needs to set the parameter values of all TAGS columns
 TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? using weather_test tags (?, ?) (ts, c1, c2) values(?, ?, ?)");
 s.setTableName("w1");
+// set tags
 s.setTagInt(0, r.nextInt(10));
 s.setTagString(1, "Beijing");
 int numOfRows = 10;
+// set values
 ArrayList<Long> ts = new ArrayList<>();
 for (int i = 0; i < numOfRows; i++){
    ts.add(System.currentTimeMillis() + i);
@@ -341,9 +344,10 @@ for (int i = 0; i < numOfRows; i++){
 }
 s.setString(2, s2, 10);
+// The cache is not cleared after AddBatch. Do not bind new data again before ExecuteBatch
 s.columnDataAddBatch();
 s.columnDataExecuteBatch();
+// Clear the cache, after which you can bind new data(including table names, tags, values):
 s.columnDataClearBatch();
 s.columnDataCloseBatch();
 ```
@@ -499,6 +503,10 @@ Query OK, 1 row(s) in set (0.000141s)
 - Please refer to [SpringJdbcTemplate](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/SpringJdbcTemplate) if using taos-jdbcdriver in Spring JdbcTemplate.
 - Please refer to [springbootdemo](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/springbootdemo) if using taos-jdbcdriver in Spring JdbcTemplate.
+## Example Codes
+you see sample code here: ![JDBC example](https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC)
 ## FAQ
 - java.lang.UnsatisfiedLinkError: no taos in java.library.path

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

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -128,7 +128,7 @@ typedef struct {
  int32_t kvLen;    // len of SKVRow
 } SMemRowInfo;
 typedef struct {
-  uint8_t      memRowType;   // default is 0, that is SDataRow
+  uint8_t      memRowType;   // default is 0, that is SDataRow 
  uint8_t      compareStat;  // 0 no need, 1 need compare
  TDRowTLenT   kvRowInitLen;
  SMemRowInfo *rowInfo;

--- 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);

--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1527,8 +1527,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);

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -2070,9 +2070,10 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
  }
  bool hasDistinct = false;
  bool hasAgg      = false; 
-  size_t  numOfExpr = taosArrayGetSize(pSelNodeList);
+  size_t numOfExpr = taosArrayGetSize(pSelNodeList);
  int32_t distIdx = -1; 
  for (int32_t i = 0; i < numOfExpr; ++i) {
    int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
@@ -2127,7 +2128,6 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
    }
  }
  //TODO(dengyihao), refactor as function     
  //handle distinct func mixed with other func 
  if (hasDistinct == true) {
@@ -2143,6 +2143,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
    if (pQueryInfo->pDownstream != NULL) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
    }
    pQueryInfo->distinct = true;
  }
@@ -2666,7 +2667,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
          tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MICRO);
        } else if (info.precision == TSDB_TIME_PRECISION_MICRO) {
          tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MILLI);
-	}
+	      }
        if (tickPerSec <= 0 || tickPerSec < TSDB_TICK_PER_SECOND(info.precision)) {
          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
@@ -2700,8 +2701,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
        assert(ids.num == 1);
        tscColumnListInsert(pQueryInfo->colList, ids.ids[0].columnIndex, pExpr->base.uid, pSchema);
      }
      tscInsertPrimaryTsSourceColumn(pQueryInfo, pExpr->base.uid);
      return TSDB_CODE_SUCCESS;
    }
@@ -3083,7 +3084,6 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
          tscColumnListInsert(pQueryInfo->colList, index.columnIndex, uid, &s);
        }
      }
      tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
      return TSDB_CODE_SUCCESS;
    }
@@ -4681,7 +4681,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
        }
        pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_QUERY;
-        ret = setExprToCond(&pCondExpr->pJoinExpr, *pExpr, NULL, parentOptr, pQueryInfo->msg);
+        ret = setExprToCond(&pCondExpr->pJoinExpr, *pExpr, NULL, parentOptr, pCmd->payload);
        *pExpr = NULL;
        if (type) {
          *type |= TSQL_EXPR_JOIN;
@@ -5663,6 +5663,7 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
  const char* msg3 = "top/bottom not support fill";
  const char* msg4 = "illegal value or data overflow";
  const char* msg5 = "fill only available for interval query";
+  const char* msg6 = "not supported function now";
  if ((!isTimeWindowQuery(pQueryInfo)) && (!tscIsPointInterpQuery(pQueryInfo))) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
@@ -5701,6 +5702,9 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
    }
  } else if (strncasecmp(pItem->pVar.pz, "prev", 4) == 0 && pItem->pVar.nLen == 4) {
    pQueryInfo->fillType = TSDB_FILL_PREV;
+    if (tscIsPointInterpQuery(pQueryInfo) && pQueryInfo->order.order == TSDB_ORDER_DESC) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+    }
  } else if (strncasecmp(pItem->pVar.pz, "next", 4) == 0 && pItem->pVar.nLen == 4) {
    pQueryInfo->fillType = TSDB_FILL_NEXT;
  } else if (strncasecmp(pItem->pVar.pz, "linear", 6) == 0 && pItem->pVar.nLen == 6) {
@@ -5805,14 +5809,13 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
  const char* msg7 = "only primary timestamp/column in groupby clause allowed as order column";
  const char* msg8 = "only column in groupby clause allowed as order column";
  const char* msg9 = "orderby column must projected in subquery";
+  const char* msg10 = "not support distinct mixed with order by";
  setDefaultOrderInfo(pQueryInfo);
  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  if (pSqlNode->pSortOrder == NULL) {
-  if (pQueryInfo->distinct || pSqlNode->pSortOrder == NULL) {
+    return TSDB_CODE_SUCCESS; 
-    return TSDB_CODE_SUCCESS;
+  } 
-  }
  char* pMsgBuf = tscGetErrorMsgPayload(pCmd);
  SArray* pSortOrder = pSqlNode->pSortOrder;
@@ -5832,6 +5835,9 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
      return invalidOperationMsg(pMsgBuf, msg2);
    }
  }
+  if (size > 0 && pQueryInfo->distinct) {
+    return invalidOperationMsg(pMsgBuf, msg10); 
+  }
  // handle the first part of order by
  tVariant* pVar = taosArrayGet(pSortOrder, 0);
@@ -5900,12 +5906,14 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
        pQueryInfo->order.orderColId = pSchema[index.columnIndex].colId;
      } else if (isTopBottomQuery(pQueryInfo)) {
        /* order of top/bottom query in interval is not valid  */
        int32_t pos = tscExprTopBottomIndex(pQueryInfo);
        assert(pos > 0);
        SExprInfo* pExpr = tscExprGet(pQueryInfo, pos - 1);
        assert(pExpr->base.functionId == TSDB_FUNC_TS);
        pExpr = tscExprGet(pQueryInfo, pos);
        if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
          return invalidOperationMsg(pMsgBuf, msg5);
        }
@@ -5996,13 +6004,13 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
          return invalidOperationMsg(pMsgBuf, msg8);
        }
      } else {
-        /* order of top/bottom query in interval is not valid  */
        int32_t pos = tscExprTopBottomIndex(pQueryInfo);
        assert(pos > 0);
        SExprInfo* pExpr = tscExprGet(pQueryInfo, pos - 1);
        assert(pExpr->base.functionId == TSDB_FUNC_TS);
        pExpr = tscExprGet(pQueryInfo, pos);
        if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
          return invalidOperationMsg(pMsgBuf, msg5);
        }
@@ -8710,6 +8718,7 @@ static STableMeta* extractTempTableMetaFromSubquery(SQueryInfo* pUpstream) {
    n += 1;
  }
  info->numOfColumns = n;
  return meta;
@@ -8740,7 +8749,6 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
    return code;
  }
  // create dummy table meta info
  STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
  if (pTableMetaInfo1 == NULL) {

--- 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
@@ -2038,17 +2038,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 +2403,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);
        }
      }
    }
@@ -2607,7 +2608,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);
@@ -2765,27 +2766,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;
+    }
-      pParentSql->retry++;
+    if (userSql == NULL) {
-      pParentSql->res.code = TSDB_CODE_SUCCESS;
+      userSql = pParentSql;
-      tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
+    }
-          tstrerror(code), pParentSql->retry);
-      code = tsParseSql(pParentSql, true);
+    if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && userSql->retry < userSql->maxRetry) {
+      if (userSql != pParentSql) {
+        tscFreeRetrieveSup(pParentSql);
+      }
+      tscFreeSubobj(userSql);      
+      tfree(userSql->pSubs);
+      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 +2872,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;

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -403,6 +403,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 +680,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 +1259,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;
@@ -3634,10 +3658,10 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
  pNewQueryInfo->prjOffset = pQueryInfo->prjOffset;
  pNewQueryInfo->numOfTables = 0;
  pNewQueryInfo->pTableMetaInfo = NULL;
-  pNewQueryInfo->bufLen   =  pQueryInfo->bufLen;
+  pNewQueryInfo->bufLen = pQueryInfo->bufLen;
-  pNewQueryInfo->distinct =  pQueryInfo->distinct;
  pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
+  pNewQueryInfo->distinct =  pQueryInfo->distinct;
  if (pNewQueryInfo->buf == NULL) {
    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
    goto _error;
@@ -3853,8 +3877,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);
@@ -3863,7 +3886,13 @@ 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)) {
+      tscAsyncResultOnError(pParentSql);
+      return;
+    }
+    tscFreeSubobj(pParentSql);    
+    tfree(pParentSql->pSubs);
    pParentSql->res.code = TSDB_CODE_SUCCESS;
    pParentSql->retry++;
@@ -3871,6 +3900,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;
@@ -3905,9 +3937,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);
@@ -3933,6 +3967,9 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
      pNew->sqlstr    = strdup(pSql->sqlstr);
      pNew->fp        = 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
@@ -4465,10 +4502,12 @@ 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) {
+  if (sz != 0) {
    memset((char *)p, 0, sz);
  }
  if (NULL == taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz)) {
    tfree(p);
  } else {
@@ -4478,11 +4517,12 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
  // 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;
    }

--- 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
@@ -163,6 +163,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,7 +84,7 @@ 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;
 int8_t  tsTscEnableRecordSql = 0;
 // the maximum number of results for projection query on super table that are returned from
@@ -152,7 +152,6 @@ int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;
 int32_t tsTsdbMetaCompactRatio = TSDB_META_COMPACT_RATIO;
 // tsdb config 
 // For backward compatibility
 bool tsdbForceKeepFile = false;
@@ -210,6 +209,7 @@ char   tsScriptDir[PATH_MAX] = {0};
 char   tsTempDir[PATH_MAX] = "/tmp/";
 int32_t  tsDiskCfgNum = 0;
+int32_t tsTopicBianryLen = 16000;
 #ifndef _STORAGE
 SDiskCfg tsDiskCfg[1];
@@ -570,7 +570,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;
@@ -1238,6 +1237,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;

--- a/go @ 050667e5
+++ b/go @ 050667e5
-Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4
+Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f
--- a/hivemq-tdengine-extension @ b62a26ec
+++ b/hivemq-tdengine-extension @ b62a26ec
-Subproject commit ce5201014136503d34fecbd56494b67b4961056c
+Subproject commit b62a26ecc164a310104df57691691b237e091c89
--- 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/kit/shell/src/shellCheck.c
+++ b/src/kit/shell/src/shellCheck.c
@@ -72,12 +72,13 @@ static int32_t shellShowTables(TAOS *con, char *db) {
      int32_t tbIndex = tbNum++;
      if (tbMallocNum < tbNum) {
        tbMallocNum = (tbMallocNum * 2 + 1);
-        tbNames = realloc(tbNames, tbMallocNum * sizeof(char *));
+        char** tbNames1 = realloc(tbNames, tbMallocNum * sizeof(char *));
-        if (tbNames == NULL) {
+        if (tbNames1 == NULL) {
          fprintf(stdout, "failed to malloc tablenames, num:%d\n", tbMallocNum);
          code = TSDB_CODE_TSC_OUT_OF_MEMORY;
          break;
        }
+        tbNames = tbNames1;
      }
      tbNames[tbIndex] = malloc(TSDB_TABLE_NAME_LEN);

--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -443,6 +443,7 @@ typedef struct SThreadInfo_S {
    uint64_t  start_table_from;
    uint64_t  end_table_to;
    int64_t   ntables;
+    int64_t   tables_created;
    uint64_t  data_of_rate;
    int64_t   start_time;
    char*     cols;
@@ -639,6 +640,7 @@ SArguments g_args = {
 static SDbs            g_Dbs;
 static int64_t         g_totalChildTables = 0;
+static int64_t         g_actualChildTables = 0;
 static SQueryMetaInfo  g_queryInfo;
 static FILE *          g_fpOfInsertResult = NULL;
@@ -964,6 +966,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                exit(EXIT_FAILURE);
            }
            arguments->num_of_tables = atoi(argv[++i]);
+            g_totalChildTables = arguments->num_of_tables;
        } else if (strcmp(argv[i], "-n") == 0) {
            if ((argc == i+1) ||
                    (!isStringNumber(argv[i+1]))) {
@@ -1134,7 +1137,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                exit(EXIT_FAILURE);
            }
        } else if ((strcmp(argv[i], "--version") == 0) ||
-                (strcmp(argv[i], "-V") == 0)){
+                (strcmp(argv[i], "-V") == 0)) {
            printVersion();
            exit(0);
        } else if (strcmp(argv[i], "--help") == 0) {
@@ -1345,14 +1348,14 @@ static void selectAndGetResult(
    }
 }
-static char *rand_bool_str(){
+static char *rand_bool_str() {
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
    return g_randbool_buff + ((cursor % MAX_PREPARED_RAND) * BOOL_BUFF_LEN);
 }
-static int32_t rand_bool(){
+static int32_t rand_bool() {
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
@@ -1485,7 +1488,7 @@ static char *demo_phase_float_str() {
    return g_rand_phase_buff + ((cursor % MAX_PREPARED_RAND) * FLOAT_BUFF_LEN);
 }
-static float UNUSED_FUNC demo_phase_float(){
+static float UNUSED_FUNC demo_phase_float() {
    static int cursor;
    cursor++;
    if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
@@ -1564,7 +1567,7 @@ static void init_rand_data() {
    g_randdouble_buff = calloc(1, DOUBLE_BUFF_LEN * MAX_PREPARED_RAND);
    assert(g_randdouble_buff);
-    for (int i = 0; i < MAX_PREPARED_RAND; i++){
+    for (int i = 0; i < MAX_PREPARED_RAND; i++) {
        g_randint[i] = (int)(taosRandom() % 65535);
        sprintf(g_randint_buff + i * INT_BUFF_LEN, "%d",
                g_randint[i]);
@@ -3276,6 +3279,7 @@ static void* createTable(void *sarg)
                    pThreadInfo->db_name,
                    g_args.tb_prefix, i,
                    pThreadInfo->cols);
+            batchNum ++;
        } else {
            if (stbInfo == NULL) {
                free(pThreadInfo->buffer);
@@ -3325,13 +3329,14 @@ static void* createTable(void *sarg)
        len = 0;
        if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
-                    NO_INSERT_TYPE, false)){
+                    NO_INSERT_TYPE, false)) {
            errorPrint2("queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
            free(pThreadInfo->buffer);
            return NULL;
        }
+        pThreadInfo->tables_created += batchNum;
-        uint64_t  currentPrintTime = taosGetTimestampMs();
+        uint64_t currentPrintTime = taosGetTimestampMs();
        if (currentPrintTime - lastPrintTime > 30*1000) {
            printf("thread[%d] already create %"PRIu64" - %"PRIu64" tables\n",
                    pThreadInfo->threadID, pThreadInfo->start_table_from, i);
@@ -3401,6 +3406,7 @@ static int startMultiThreadCreateChildTable(
        pThreadInfo->use_metric = true;
        pThreadInfo->cols = cols;
        pThreadInfo->minDelay = UINT64_MAX;
+        pThreadInfo->tables_created = 0;
        pthread_create(pids + i, NULL, createTable, pThreadInfo);
    }
@@ -3411,6 +3417,8 @@ static int startMultiThreadCreateChildTable(
    for (int i = 0; i < threads; i++) {
        threadInfo *pThreadInfo = infos + i;
        taos_close(pThreadInfo->taos);
+        g_actualChildTables += pThreadInfo->tables_created;
    }
    free(pids);
@@ -3437,7 +3445,6 @@ static void createChildTables() {
                    verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
                            g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
                    uint64_t startFrom = 0;
-                    g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
                    verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
                            __func__, __LINE__, g_totalChildTables, startFrom);
@@ -4232,6 +4239,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
                goto PARSE_OVER;
            }
            g_Dbs.db[i].superTbls[j].childTblCount = count->valueint;
+            g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
            cJSON *dataSource = cJSON_GetObjectItem(stbInfo, "data_source");
            if (dataSource && dataSource->type == cJSON_String
@@ -4936,7 +4944,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
                cJSON *result = cJSON_GetObjectItem(sql, "result");
                if (result != NULL && result->type == cJSON_String
-                        && result->valuestring != NULL){
+                        && result->valuestring != NULL) {
                    tstrncpy(g_queryInfo.superQueryInfo.result[j],
                            result->valuestring, MAX_FILE_NAME_LEN);
                } else if (NULL == result) {
@@ -7586,7 +7594,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
                }
                int ret = taos_stmt_prepare(pThreadInfo->stmt, stmtBuffer, 0);
-                if (ret != 0){
+                if (ret != 0) {
                    free(pids);
                    free(infos);
                    free(stmtBuffer);
@@ -7932,18 +7940,30 @@ static int insertTestProcess() {
    double start;
    double end;
-    // create child tables
-    start = taosGetTimestampMs();
-    createChildTables();
-    end = taosGetTimestampMs();
    if (g_totalChildTables > 0) {
-        fprintf(stderr, "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
+        fprintf(stderr,
-                (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+                "creating %"PRId64" table(s) with %d thread(s)\n\n",
+                g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+        if (g_fpOfInsertResult) {
+            fprintf(g_fpOfInsertResult,
+                "creating %"PRId64" table(s) with %d thread(s)\n\n",
+                g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+        }
+        // create child tables
+        start = taosGetTimestampMs();
+        createChildTables();
+        end = taosGetTimestampMs();
+        fprintf(stderr,
+                "Spent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
+                (end - start)/1000.0, g_totalChildTables,
+                g_Dbs.threadCountByCreateTbl, g_actualChildTables);
        if (g_fpOfInsertResult) {
            fprintf(g_fpOfInsertResult,
-                    "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
+                "Spent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
-                    (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+                (end - start)/1000.0, g_totalChildTables,
+                g_Dbs.threadCountByCreateTbl, g_actualChildTables);
        }
    }

--- a/src/kit/taospack/taospack.c
+++ b/src/kit/taospack/taospack.c
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(WINDOWS) 
 int main(int argc, char *argv[]) {
  printf("welcome to use taospack tools v1.3 for windows.\n");
@@ -148,7 +149,10 @@ float* read_float(const char* inFile, int* pcount){
    //printf(" buff=%s float=%.50f \n ", buf, floats[fi]);
    if ( ++fi == malloc_cnt ) {
      malloc_cnt += 100000;
-      floats = realloc(floats, malloc_cnt*sizeof(float));
+      float* floats1 = realloc(floats, malloc_cnt*sizeof(float));
+      if(floats1 == NULL)
+         break;
+      floats = floats1;   
    }
    memset(buf, 0, sizeof(buf));
  }
@@ -601,7 +605,6 @@ void test_threadsafe_double(int thread_count){
 }
 void unitTestFloat() {
  float ft1 [] = {1.11, 2.22, 3.333};
@@ -662,7 +665,50 @@ void unitTestFloat() {
  free(ft2);
  free(buff);
  free(output); 
+}
+void leakFloat() {
+  int cnt = sizeof(g_ft1)/sizeof(float);
+  float* floats = g_ft1;
+  int algorithm = 2;
+  // compress
+  const char* input = (const char*)floats;
+  int input_len = cnt * sizeof(float);
+  int output_len = input_len + 1024;
+  char* output = (char*) malloc(output_len);
+  char* buff = (char*) malloc(input_len);
+  int buff_len = input_len;
+  int ret_len = 0;
+  ret_len = tsCompressFloatLossy(input, input_len, cnt, output, output_len, algorithm, buff, buff_len);
+  if(ret_len == 0) {
+    printf(" compress float error.\n");
+    free(buff);
+    free(output); 
+    return ;
+  }
+  float* ft2 = (float*)malloc(input_len); 
+  ret_len = tsDecompressFloatLossy(output, ret_len, cnt, (char*)ft2, input_len, algorithm, buff, buff_len);
+  if(ret_len == 0) {
+    printf(" decompress float error.\n");
+  }
+  free(ft2);
+  free(buff);
+  free(output); 
+}
+void leakTest(){
+  for(int i=0; i< 90000000000000; i++){
+    if(i%10000==0)
+        printf(" ---------- %d ---------------- \n", i);
+    leakFloat();
+  }
 }
 #define DB_CNT 500
@@ -689,7 +735,7 @@ extern char Compressor [];
 //   -----------------  main ----------------------
 //
 int main(int argc, char *argv[]) {
-  printf("welcome to use taospack tools v1.3\n");
+  printf("welcome to use taospack tools v1.6\n");
  //printf(" sizeof(int)=%d\n",  (int)sizeof(int));
  //printf(" sizeof(long)=%d\n", (int)sizeof(long));
@@ -753,6 +799,9 @@ int main(int argc, char *argv[]) {
    if(strcmp(argv[1], "-mem") == 0) {
      memTest();
    } 
+    else if(strcmp(argv[1], "-leak") == 0) {
+      leakTest();
+    }
  }
  else{
    unitTestFloat();

--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2921,10 +2921,11 @@ static SMultiTableMeta* ensureMsgBufferSpace(SMultiTableMeta *pMultiMeta, SArray
      (*totalMallocLen) *= 2;
    }
-    pMultiMeta = realloc(pMultiMeta, *totalMallocLen);
+    SMultiTableMeta* pMultiMeta1 = realloc(pMultiMeta, *totalMallocLen);
-    if (pMultiMeta == NULL) {
+    if (pMultiMeta1 == NULL) {
      return NULL;
    }
+    pMultiMeta = pMultiMeta1;
  }
  return pMultiMeta;

--- a/src/os/src/detail/osMemory.c
+++ b/src/os/src/detail/osMemory.c
@@ -504,8 +504,9 @@ void * taosTRealloc(void *ptr, size_t size) {
  void * tptr = (void *)((char *)ptr - sizeof(size_t));
  size_t tsize = size + sizeof(size_t);
-  tptr = realloc(tptr, tsize);
+  void* tptr1 = realloc(tptr, tsize);
-  if (tptr == NULL) return NULL;
+  if (tptr1 == NULL) return NULL;
+  tptr = tptr1;
  *(size_t *)tptr = size;

--- a/src/os/src/windows/wGetline.c
+++ b/src/os/src/windows/wGetline.c
@@ -81,11 +81,13 @@ int32_t getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int32_t
        *n += MIN_CHUNK;
      nchars_avail = (int32_t)(*n + *lineptr - read_pos);
-      *lineptr = realloc(*lineptr, *n);
+      char* lineptr1 = realloc(*lineptr, *n);
-      if (!*lineptr) {
+      if (!lineptr1) {
        errno = ENOMEM;
        return -1;
      }
+      *lineptr = lineptr1;
      read_pos = *n - nchars_avail + *lineptr;
      assert((*lineptr + *n) == (read_pos + nchars_avail));
    }

--- a/src/query/inc/qExtbuffer.h
+++ b/src/query/inc/qExtbuffer.h
@@ -220,6 +220,8 @@ tOrderDescriptor *tOrderDesCreate(const int32_t *orderColIdx, int32_t numOfOrder
 void tOrderDescDestroy(tOrderDescriptor *pDesc);
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn);
 void tColModelAppend(SColumnModel *dstModel, tFilePage *dstPage, void *srcData, int32_t srcStartRows,
                     int32_t numOfRowsToWrite, int32_t srcCapacity);

--- a/src/query/inc/queryLog.h
+++ b/src/query/inc/queryLog.h
@@ -24,10 +24,10 @@ extern "C" {
 extern uint32_t qDebugFlag;
-#define qFatal(...) do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", 255, __VA_ARGS__); }}  while(0)
+#define qFatal(...) do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", qDebugFlag, __VA_ARGS__); }}  while(0)
-#define qError(...) do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", 255, __VA_ARGS__); }}  while(0)
+#define qError(...) do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", qDebugFlag, __VA_ARGS__); }}  while(0)
-#define qWarn(...)  do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", 255, __VA_ARGS__); }}   while(0)
+#define qWarn(...)  do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ",  qDebugFlag, __VA_ARGS__); }}   while(0)
-#define qInfo(...)  do { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", 255, __VA_ARGS__); }}        while(0)
+#define qInfo(...)  do { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }}        while(0)
 #define qDebug(...) do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
 #define qTrace(...) do { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
 #define qDump(a, l) do { if (qDebugFlag & DEBUG_DUMP)  { taosDumpData((unsigned char *)a, l); }} while(0)

--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -3670,6 +3670,8 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
    return;
  }
+  bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
  if (pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP) {
    *(TSKEY *)pCtx->pOutput = pCtx->startTs;
  } else if (type == TSDB_FILL_NULL) {
@@ -3677,7 +3679,7 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
  } else if (type == TSDB_FILL_SET_VALUE) {
    tVariantDump(&pCtx->param[1], pCtx->pOutput, pCtx->inputType, true);
  } else {
-    if (pCtx->start.key != INT64_MIN && pCtx->start.key < pCtx->startTs && pCtx->end.key > pCtx->startTs) {
+    if (pCtx->start.key != INT64_MIN && ((ascQuery && pCtx->start.key <= pCtx->startTs && pCtx->end.key >= pCtx->startTs) || ((!ascQuery) && pCtx->start.key >= pCtx->startTs && pCtx->end.key <= pCtx->startTs))) {
      if (type == TSDB_FILL_PREV) {
        if (IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL) {
          SET_TYPED_DATA(pCtx->pOutput, pCtx->inputType, pCtx->start.val);
@@ -3716,13 +3718,14 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
      TSKEY skey = GET_TS_DATA(pCtx, 0);
      if (type == TSDB_FILL_PREV) {
-        if (skey > pCtx->startTs) {
+        if ((ascQuery && skey > pCtx->startTs) || ((!ascQuery) && skey < pCtx->startTs)) {
          return;
        }
        if (pCtx->size > 1) {
          TSKEY ekey = GET_TS_DATA(pCtx, 1);
-          if (ekey > skey && ekey <= pCtx->startTs) {
+          if ((ascQuery &&  ekey > skey && ekey <= pCtx->startTs) ||
+             ((!ascQuery) && ekey < skey && ekey >= pCtx->startTs)){
            skey = ekey;
          }
        }
@@ -3731,10 +3734,10 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
        TSKEY ekey = skey;
        char* val = NULL;
-        if (ekey < pCtx->startTs) {
+        if ((ascQuery && ekey < pCtx->startTs) || ((!ascQuery) && ekey > pCtx->startTs)) {
          if (pCtx->size > 1) {
            ekey = GET_TS_DATA(pCtx, 1);
-            if (ekey < pCtx->startTs) {
+            if ((ascQuery && ekey < pCtx->startTs) || ((!ascQuery) && ekey > pCtx->startTs)) {
              return;
            }
@@ -3755,12 +3758,11 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
        TSKEY ekey = GET_TS_DATA(pCtx, 1);
        // no data generated yet
-        if (!(skey < pCtx->startTs && ekey > pCtx->startTs)) {
+        if ((ascQuery && !(skey <= pCtx->startTs && ekey >= pCtx->startTs))
+           || ((!ascQuery) && !(skey >= pCtx->startTs && ekey <= pCtx->startTs))) {
          return;
        }
-        assert(pCtx->start.key == INT64_MIN && skey < pCtx->startTs && ekey > pCtx->startTs);
        char *start = GET_INPUT_DATA(pCtx, 0);
        char *end = GET_INPUT_DATA(pCtx, 1);
@@ -3788,11 +3790,37 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
 static void interp_function(SQLFunctionCtx *pCtx) {
  // at this point, the value is existed, return directly
  if (pCtx->size > 0) {
-    // impose the timestamp check
+    bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
-    TSKEY key = GET_TS_DATA(pCtx, 0);
+    TSKEY key;
+    char *pData;
+    int32_t typedData = 0;
+    if (ascQuery) {
+      key = GET_TS_DATA(pCtx, 0);
+      pData = GET_INPUT_DATA(pCtx, 0);
+    } else {
+      key = pCtx->start.key;
+      if (key == INT64_MIN) {
+        key = GET_TS_DATA(pCtx, 0);
+        pData = GET_INPUT_DATA(pCtx, 0);
+      } else {        
+        if (!(IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL)) {
+          pData = pCtx->start.ptr;
+        } else {
+          typedData = 1;
+          pData = (char *)&pCtx->start.val;
+        }
+      }
+    }
+    //if (key == pCtx->startTs && (ascQuery || !(IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL))) {
    if (key == pCtx->startTs) {
-      char *pData = GET_INPUT_DATA(pCtx, 0);
+      if (typedData) {
-      assignVal(pCtx->pOutput, pData, pCtx->inputBytes, pCtx->inputType);
+        SET_TYPED_DATA(pCtx->pOutput, pCtx->inputType, *(double *)pData);
+      } else {
+        assignVal(pCtx->pOutput, pData, pCtx->inputBytes, pCtx->inputType);
+      }
      SET_VAL(pCtx, 1, 1);
    } else {
      interp_function_impl(pCtx);

--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -45,7 +45,7 @@
 #define MULTI_KEY_DELIM  "-"
-#define HASH_CAPACITY_LIMIT  10000000 
+#define HASH_CAPACITY_LIMIT  10000000
 #define TIME_WINDOW_COPY(_dst, _src)  do {\
   (_dst).skey = (_src).skey;\
@@ -1327,6 +1327,16 @@ void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo,
        pCtx[k].end.key = curTs;
        pCtx[k].end.val = v2;
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          if (prevRowIndex == -1) {
+            pCtx[k].start.ptr = (char *)pRuntimeEnv->prevRow[index];
+          } else {
+            pCtx[k].start.ptr = (char *)pColInfo->pData + prevRowIndex * pColInfo->info.bytes;
+          }
+          pCtx[k].end.ptr = (char *)pColInfo->pData + curRowIndex * pColInfo->info.bytes;
+        }
      }
    } else if (functionId == TSDB_FUNC_TWA) {
      SPoint point1 = (SPoint){.key = prevTs,    .val = &v1};
@@ -1596,6 +1606,7 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
  SResultRow* pResult = NULL;
  int32_t forwardStep = 0;
  int32_t ret = 0;
+  STimeWindow preWin = win;
  while (1) {
    // null data, failed to allocate more memory buffer
@@ -1610,12 +1621,13 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
    // window start(end) key interpolation
    doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
-    doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+    doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+    preWin = win;
    int32_t prevEndPos = (forwardStep - 1) * step + startPos;
    startPos = getNextQualifiedWindow(pQueryAttr, &win, &pSDataBlock->info, tsCols, binarySearchForKey, prevEndPos);
    if (startPos < 0) {
-      if (win.skey <= pQueryAttr->window.ekey) {
+      if ((ascQuery && win.skey <= pQueryAttr->window.ekey) || ((!ascQuery) && win.ekey >= pQueryAttr->window.ekey)) {
        int32_t code = setResultOutputBufByKey(pRuntimeEnv, pResultRowInfo, pSDataBlock->info.tid, &win, masterScan, &pResult, tableGroupId,
                                               pInfo->pCtx, numOfOutput, pInfo->rowCellInfoOffset);
        if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
@@ -1626,7 +1638,7 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
        // window start(end) key interpolation
        doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
-        doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+        doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
      }
      break;
@@ -3570,7 +3582,7 @@ void setDefaultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SOptrBasicInfo *pInfo, i
  SResultRowInfo* pResultRowInfo = &pInfo->resultRowInfo;
  int64_t tid = 0;
-  pRuntimeEnv->keyBuf = realloc(pRuntimeEnv->keyBuf, sizeof(tid) + sizeof(int64_t) + POINTER_BYTES);   
+  pRuntimeEnv->keyBuf = realloc(pRuntimeEnv->keyBuf, sizeof(tid) + sizeof(int64_t) + POINTER_BYTES);
  SResultRow* pRow = doSetResultOutBufByKey(pRuntimeEnv, pResultRowInfo, tid, (char *)&tid, sizeof(tid), true, uid);
  for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
@@ -7156,14 +7168,14 @@ static bool initMultiDistinctInfo(SDistinctOperatorInfo *pInfo, SOperatorInfo* p
      SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, j);
      if (pColDataInfo->info.colId == pOperator->pExpr[i].base.resColId) {
        SDistinctDataInfo item = {.index = j, .type = pColDataInfo->info.type, .bytes = pColDataInfo->info.bytes};
-        taosArrayInsert(pInfo->pDistinctDataInfo, i, &item);     
+        taosArrayInsert(pInfo->pDistinctDataInfo, i, &item);
      }
    }
  }
  pInfo->totalBytes += (int32_t)strlen(MULTI_KEY_DELIM) * (pOperator->numOfOutput);
  pInfo->buf        =  calloc(1, pInfo->totalBytes);
  return  taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput ? true : false;
-} 
+}
 static void buildMultiDistinctKey(SDistinctOperatorInfo *pInfo, SSDataBlock *pBlock, int32_t rowId) {
  char *p = pInfo->buf;
@@ -7188,11 +7200,13 @@ static void buildMultiDistinctKey(SDistinctOperatorInfo *pInfo, SSDataBlock *pBl
    p += strlen(MULTI_KEY_DELIM);
  }
 }
 static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
  SOperatorInfo* pOperator = (SOperatorInfo*) param;
  if (pOperator->status == OP_EXEC_DONE) {
    return NULL;
  }
  SDistinctOperatorInfo* pInfo = pOperator->info;
  SSDataBlock* pRes = pInfo->pRes;
@@ -7247,11 +7261,11 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
        pRes->info.rows += 1;
      } 
    }
    if (pRes->info.rows >= pInfo->threshold) {
      break;
    }
  }
  return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
 }

--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
@@ -768,60 +768,6 @@ void tColDataQSort(tOrderDescriptor *pDescriptor, int32_t numOfRows, int32_t sta
  free(buf);
 }
-void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn) {
-  assert(numOfRows > 0 && numOfCols > 0 && index >= 0 && index < numOfCols);
-  int32_t bytes = pSchema[index].bytes;
-  int32_t size = bytes + sizeof(int32_t);
-  char* buf = calloc(1, size * numOfRows);
-  for(int32_t i = 0; i < numOfRows; ++i) {
-    char* dest = buf + size * i;
-    memcpy(dest, ((char*)pCols[index]) + bytes * i, bytes);
-    *(int32_t*)(dest+bytes) = i;
-  }
-  qsort(buf, numOfRows, size, compareFn);
-  int32_t prevLength = 0;
-  char* p = NULL;
-  for(int32_t i = 0; i < numOfCols; ++i) {
-    int32_t bytes1 = pSchema[i].bytes;
-    if (i == index) {
-      for(int32_t j = 0; j < numOfRows; ++j){
-        char* src  = buf + (j * size);
-        char* dest = (char*) pCols[i] + (j * bytes1);
-        memcpy(dest, src, bytes1);
-      }
-    } else {
-      // make sure memory buffer is enough
-      if (prevLength < bytes1) {
-        char *tmp = realloc(p, bytes1 * numOfRows);
-        assert(tmp);
-        p = tmp;
-        prevLength = bytes1;
-      }
-      memcpy(p, pCols[i], bytes1 * numOfRows);
-      for(int32_t j = 0; j < numOfRows; ++j){
-        char* dest = (char*) pCols[i] + bytes1 * j;
-        int32_t newPos = *(int32_t*)(buf + (j * size) + bytes);
-        char* src = p + (newPos * bytes1);
-        memcpy(dest, src, bytes1);
-      }
-    }
-  }
-  tfree(buf);
-  tfree(p);
-}
 /*
 * deep copy of sschema
 */
@@ -1157,3 +1103,57 @@ void tOrderDescDestroy(tOrderDescriptor *pDesc) {
  destroyColumnModel(pDesc->pColumnModel);
  tfree(pDesc);
 }
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn) {
+  assert(numOfRows > 0 && numOfCols > 0 && index >= 0 && index < numOfCols);
+  int32_t bytes = pSchema[index].bytes;
+  int32_t size = bytes + sizeof(int32_t);
+  char* buf = calloc(1, size * numOfRows);
+  for(int32_t i = 0; i < numOfRows; ++i) {
+    char* dest = buf + size * i;
+    memcpy(dest, ((char*) pCols[index]) + bytes * i, bytes);
+    *(int32_t*)(dest+bytes) = i;
+  }
+  qsort(buf, numOfRows, size, compareFn);
+  int32_t prevLength = 0;
+  char* p = NULL;
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    int32_t bytes1 = pSchema[i].bytes;
+    if (i == index) {
+      for(int32_t j = 0; j < numOfRows; ++j){
+        char* src  = buf + (j * size);
+        char* dest = ((char*)pCols[i]) + (j * bytes1);
+        memcpy(dest, src, bytes1);
+      }
+    } else {
+      // make sure memory buffer is enough
+      if (prevLength < bytes1) {
+        char *tmp = realloc(p, bytes1 * numOfRows);
+        assert(tmp);
+        p = tmp;
+        prevLength = bytes1;
+      }
+      memcpy(p, pCols[i], bytes1 * numOfRows);
+      for(int32_t j = 0; j < numOfRows; ++j){
+        char* dest = ((char*)pCols[i]) + bytes1 * j;
+        int32_t newPos = *(int32_t*)(buf + (j * size) + bytes);
+        char* src = p + (newPos * bytes1);
+        memcpy(dest, src, bytes1);
+      }
+    }
+  }
+  tfree(buf);
+  tfree(p);
+}
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -698,7 +698,7 @@ SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr) {
  }
  // fill operator
-  if (pQueryAttr->fillType != TSDB_FILL_NONE && (!pQueryAttr->pointInterpQuery)) {
+  if (pQueryAttr->fillType != TSDB_FILL_NONE && pQueryAttr->interval.interval > 0) {
    op = OP_Fill;
    taosArrayPush(plan, &op);
  }

--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
@@ -223,8 +223,11 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
 static void shrinkBuffer(STSList* ptsData) {
  // shrink tmp buffer size if it consumes too many memory compared to the pre-defined size
  if (ptsData->allocSize >= ptsData->threshold * 2) {
-    ptsData->rawBuf = realloc(ptsData->rawBuf, MEM_BUF_SIZE);
+    char* rawBuf = realloc(ptsData->rawBuf, MEM_BUF_SIZE);
-    ptsData->allocSize = MEM_BUF_SIZE;
+    if(rawBuf) {
+      ptsData->rawBuf = rawBuf;
+      ptsData->allocSize = MEM_BUF_SIZE;
+    }
  }
 }

--- a/src/tsdb/inc/tsdbFS.h
+++ b/src/tsdb/inc/tsdbFS.h
@@ -18,6 +18,9 @@
 #define TSDB_FS_VERSION 0
+// ================== TSDB global config
+extern bool tsdbForceKeepFile;
 // ================== CURRENT file header info
 typedef struct {
  uint32_t version;  // Current file system version (relating to code)
@@ -110,4 +113,4 @@ static FORCE_INLINE int tsdbUnLockFS(STsdbFS* pFs) {
  return 0;
 }
 #endif /* _TD_TSDB_FS_H_ */
\ No newline at end of file
--- a/src/tsdb/src/tsdbFS.c
+++ b/src/tsdb/src/tsdbFS.c
@@ -37,6 +37,7 @@ static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired);
 static int  tsdbProcessExpiredFS(STsdbRepo *pRepo);
 static int  tsdbCreateMeta(STsdbRepo *pRepo);
+// For backward compatibility
 // ================== CURRENT file header info
 static int tsdbEncodeFSHeader(void **buf, SFSHeader *pHeader) {
  int tlen = 0;

--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -3480,6 +3480,7 @@ void filterPrepare(void* expr, void* param) {
        SArray *arr = (SArray *)(pCond->arr);
        for (size_t i = 0; i < taosArrayGetSize(arr); i++) {
          char* p = taosArrayGetP(arr, i);
+          strtolower(varDataVal(p), varDataVal(p));
          taosHashPut(pObj, varDataVal(p),varDataLen(p), &dummy, sizeof(dummy));
        }
     } else {

--- a/src/util/inc/tcompare.h
+++ b/src/util/inc/tcompare.h
@@ -22,10 +22,10 @@ extern "C" {
 #include "os.h"
-#define TSDB_PATTERN_MATCH 0
+#define TSDB_PATTERN_MATCH               0
-#define TSDB_PATTERN_NOMATCH 1
+#define TSDB_PATTERN_NOMATCH             1
-#define TSDB_PATTERN_NOWILDCARDMATCH 2
+#define TSDB_PATTERN_NOWILDCARDMATCH     2
-#define TSDB_PATTERN_STRING_MAX_LEN 100
+#define TSDB_PATTERN_STRING_DEFAULT_LEN  100
 #define FLT_COMPAR_TOL_FACTOR    4
 #define FLT_EQUAL(_x, _y)        (fabs((_x) - (_y)) <= (FLT_COMPAR_TOL_FACTOR * FLT_EPSILON))

--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
@@ -139,8 +139,8 @@ int32_t compareFloatVal(const void *pLeft, const void *pRight) {
  }
  if (FLT_EQUAL(p1, p2)) {
    return 0;
-  } 
+  }
-  return FLT_GREATER(p1, p2) ? 1: -1; 
+  return FLT_GREATER(p1, p2) ? 1: -1;
 }
 int32_t compareFloatValDesc(const void* pLeft, const void* pRight) {
@@ -164,8 +164,8 @@ int32_t compareDoubleVal(const void *pLeft, const void *pRight) {
  }
  if (FLT_EQUAL(p1, p2)) {
    return 0;
-  } 
+  }
-  return FLT_GREATER(p1, p2) ? 1: -1; 
+  return FLT_GREATER(p1, p2) ? 1: -1;
 }
 int32_t compareDoubleValDesc(const void* pLeft, const void* pRight) {
@@ -175,7 +175,7 @@ int32_t compareDoubleValDesc(const void* pLeft, const void* pRight) {
 int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
  int32_t len1 = varDataLen(pLeft);
  int32_t len2 = varDataLen(pRight);
  if (len1 != len2) {
    return len1 > len2? 1:-1;
  } else {
@@ -224,33 +224,33 @@ int32_t compareLenPrefixedWStrDesc(const void* pLeft, const void* pRight) {
 */
 int patternMatch(const char *patterStr, const char *str, size_t size, const SPatternCompareInfo *pInfo) {
  char c, c1;
  int32_t i = 0;
  int32_t j = 0;
  while ((c = patterStr[i++]) != 0) {
    if (c == pInfo->matchAll) { /* Match "*" */
      while ((c = patterStr[i++]) == pInfo->matchAll || c == pInfo->matchOne) {
        if (c == pInfo->matchOne && (j > size || str[j++] == 0)) {
          // empty string, return not match
          return TSDB_PATTERN_NOWILDCARDMATCH;
        }
      }
      if (c == 0) {
        return TSDB_PATTERN_MATCH; /* "*" at the end of the pattern matches */
      }
      char next[3] = {toupper(c), tolower(c), 0};
      while (1) {
        size_t n = strcspn(str, next);
        str += n;
        if (str[0] == 0 || (n >= size)) {
          break;
        }
        int32_t ret = patternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
        if (ret != TSDB_PATTERN_NOMATCH) {
          return ret;
@@ -258,19 +258,19 @@ int patternMatch(const char *patterStr, const char *str, size_t size, const SPat
      }
      return TSDB_PATTERN_NOWILDCARDMATCH;
    }
    c1 = str[j++];
    if (j <= size) {
      if (c == '\\' && patterStr[i] == '_' && c1 == '_') { i++; continue; }
      if (c == c1 || tolower(c) == tolower(c1) || (c == pInfo->matchOne && c1 != 0)) {
        continue;
      }
    }
    return TSDB_PATTERN_NOMATCH;
  }
  return (str[j] == 0 || j >= size) ? TSDB_PATTERN_MATCH : TSDB_PATTERN_NOMATCH;
 }
@@ -278,13 +278,13 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
  wchar_t c, c1;
  wchar_t matchOne = L'_';  // "_"
  wchar_t matchAll = L'%';  // "%"
  int32_t i = 0;
  int32_t j = 0;
  while ((c = patterStr[i++]) != 0) {
    if (c == matchAll) { /* Match "%" */
      while ((c = patterStr[i++]) == matchAll || c == matchOne) {
        if (c == matchOne && (j > size || str[j++] == 0)) {
          return TSDB_PATTERN_NOWILDCARDMATCH;
@@ -293,33 +293,33 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
      if (c == 0) {
        return TSDB_PATTERN_MATCH;
      }
      wchar_t accept[3] = {towupper(c), towlower(c), 0};
      while (1) {
        size_t n = wcscspn(str, accept);
        str += n;
        if (str[0] == 0 || (n >= size)) {
          break;
        }
        int32_t ret = WCSPatternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
        if (ret != TSDB_PATTERN_NOMATCH) {
          return ret;
        }
      }
      return TSDB_PATTERN_NOWILDCARDMATCH;
    }
    c1 = str[j++];
    if (j <= size) {
      if (c == c1 || towlower(c) == towlower(c1) || (c == matchOne && c1 != 0)) {
        continue;
      }
    }
    return TSDB_PATTERN_NOMATCH;
  }
@@ -359,12 +359,13 @@ int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
  SPatternCompareInfo pInfo = {'%', '_'};
  assert(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN * TSDB_NCHAR_SIZE);
-  wchar_t *pattern = calloc(varDataLen(pRight) + 1, sizeof(wchar_t));
+  wchar_t *pattern = calloc(varDataLen(pRight) + 1, sizeof(wchar_t));
  memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
  int32_t ret = WCSPatternMatch(pattern, varDataVal(pLeft), varDataLen(pLeft)/TSDB_NCHAR_SIZE, &pInfo);
  free(pattern);
  return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
@@ -411,10 +412,10 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
      } else { /* normal relational comparFn */
        comparFn = compareLenPrefixedStr;
      }
      break;
    }
    case TSDB_DATA_TYPE_NCHAR: {
      if (optr == TSDB_RELATION_LIKE) {
        comparFn = compareWStrPatternComp;
@@ -435,13 +436,13 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
      comparFn = compareInt32Val;
      break;
  }
  return comparFn;
 }
 __compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order) {
  __compar_fn_t comparFn = NULL;
  switch (keyType) {
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_BOOL:
@@ -485,7 +486,7 @@ __compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order) {
      comparFn = (order == TSDB_ORDER_ASC)? compareInt32Val:compareInt32ValDesc;
      break;
  }
  return comparFn;
 }
@@ -518,7 +519,7 @@ int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size) {
    default: {  // todo refactor
      tstr* t1 = (tstr*) f1;
      tstr* t2 = (tstr*) f2;
      if (t1->len != t2->len) {
        return t1->len > t2->len? 1:-1;
      } else {

--- a/src/util/tests/skiplistTest.cpp
+++ b/src/util/tests/skiplistTest.cpp
@@ -70,7 +70,7 @@ void doubleSkipListTest() {
 }
 void randKeyTest() {
-  SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT),
+  SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT, TSDB_ORDER_ASC),
      false, getkey);
  int32_t size = 200000;

--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
@@ -540,7 +540,7 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
    pWal->version = pHead->version;
-    //wInfo("writeFp: %ld", offset);
+    // wInfo("writeFp: %ld", offset);
    if (0 != walSMemRowCheck(pHead)) {
      wError("vgId:%d, restore wal, fileId:%" PRId64 " hver:%" PRIu64 " wver:%" PRIu64 " len:%d offset:%" PRId64,
             pWal->vgId, fileId, pHead->version, pWal->version, pHead->len, offset);

--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -80,6 +80,7 @@ python3 ./test.py -f tag_lite/set.py
 python3 ./test.py -f tag_lite/smallint.py
 python3 ./test.py -f tag_lite/tinyint.py
 python3 ./test.py -f tag_lite/timestamp.py
+python3 ./test.py -f tag_lite/TestModifyTag.py
 #python3 ./test.py -f dbmgmt/database-name-boundary.py
 python3 test.py -f dbmgmt/nanoSecondCheck.py
@@ -381,7 +382,9 @@ python3 ./test.py -f query/querySession.py
 python3 test.py -f  alter/alter_create_exception.py
 python3 ./test.py -f insert/flushwhiledrop.py
 python3 ./test.py -f insert/schemalessInsert.py
-python3 ./test.py -f alter/alterColMultiTimes.py 
+python3 ./test.py -f alter/alterColMultiTimes.py
+python3 ./test.py -f query/queryWildcardLength.py
+python3 ./test.py -f query/queryTbnameUpperLower.py
 #======================p4-end===============

--- a/tests/pytest/functions/function_interp.py
+++ b/tests/pytest/functions/function_interp.py
@@ -26,18 +26,70 @@ class TDTestCase:
        self.rowNum = 10
        self.ts = 1537146000000
    def run(self):
        tdSql.prepare()
-        tdSql.execute("create table t(ts timestamp, k int)")
+        tdSql.execute("create table ap1 (ts timestamp, pav float)")
-        tdSql.execute("insert into t values('2021-1-1 1:1:1', 12);")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.119', 2.90799)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.317', 3.07399)")
-        tdSql.query("select interp(*) from t where ts='2021-1-1 1:1:1'")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.517', 0.58117)")
-        tdSql.checkRows(1)
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.717', 0.16150)")
-        tdSql.checkData(0, 1, 12)
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.918', 1.47885)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:56.569', 1.76472)")
-        tdSql.error("select interp(*) from t where ts >'2021-1-1 1:1:1' and ts < now interval(1s) fill(next)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.381', 2.13722)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.574', 4.10256)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.776', 3.55345)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.976', 1.46624)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.187', 0.17943)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.372', 2.04101)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.573', 3.20924)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.768', 1.71807)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.964', 4.60900)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.155', 4.33907)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.359', 0.76940)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.553', 0.06458)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.742', 4.59857)")
+        tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.938', 1.55081)")
+        tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (PREV)")
+        tdSql.checkRows(0)
+        tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (NEXT)")
+        tdSql.checkRows(0)
+        tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (LINEAR)")
+        tdSql.checkRows(0)
+        tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' INTERVAL(1000a) FILL (LINEAR)")
+        tdSql.checkRows(6)
+        tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' INTERVAL(1000a) FILL (NEXT)")
+        tdSql.checkRows(6)
+        tdSql.checkData(0,1,2.90799)
+        tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' INTERVAL(1000a) FILL (PREV)")
+        tdSql.checkRows(7)
+        tdSql.checkData(1,1,1.47885)
+        tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' INTERVAL(1000a) FILL (LINEAR)")
+        tdSql.checkRows(7)
+        # check desc order
+        tdSql.error("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (PREV) order by ts desc")
+        tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (NEXT) order by ts desc")
+        tdSql.checkRows(0)
+        tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (LINEAR) order by ts desc")
+        tdSql.checkRows(0)
+        tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' INTERVAL(1000a) FILL (LINEAR) order by ts desc")
+        tdSql.checkRows(6)
+        tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' INTERVAL(1000a) FILL (NEXT) order by ts desc")
+        tdSql.checkRows(6)
+        tdSql.checkData(0,1,4.60900)
+        tdSql.error("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' INTERVAL(1000a) FILL (PREV) order by ts desc")
+        tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' INTERVAL(1000a) FILL (LINEAR) order by ts desc")
+        tdSql.checkRows(7)
+        # check exception
+        tdSql.error("select interp(*) from ap1")
+        tdSql.error("select interp(*) from ap1 FILL(NEXT)")
+        tdSql.error("select interp(*) from ap1 ts >= '2021-07-25 02:19:54' FILL(NEXT)")
+        tdSql.error("select interp(*) from ap1 ts <= '2021-07-25 02:19:54' FILL(NEXT)")
+        tdSql.error("select interp(*) from ap1 where ts >'2021-07-25 02:19:59.938' and ts < now interval(1s) fill(next)")
    def stop(self):
        tdSql.close()
        tdLog.success("%s successfully executed" % __file__)

--- a/tests/pytest/functions/queryTestCases.py
+++ b/tests/pytest/functions/queryTestCases.py
--- a/tests/pytest/query/queryError.py
+++ b/tests/pytest/query/queryError.py
@@ -65,6 +65,10 @@ class TDTestCase:
        # TD-2208
        tdSql.error("select diff(tagtype),top(tagtype,1) from dev_001")
+        # TD-6006
+        tdSql.error("select * from dev_001 where 'name' is not null")
+        tdSql.error("select * from dev_001 where \"name\" = 'first'")
    def stop(self):
        tdSql.close()
        tdLog.success("%s successfully executed" % __file__)

--- a/tests/pytest/query/queryTbnameUpperLower.py
+++ b/tests/pytest/query/queryTbnameUpperLower.py
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# -*- coding: utf-8 -*-
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.common import tdCom
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+    def checkStbWhereIn(self):
+        '''
+            where in ---> upper lower mixed
+        '''
+        tdCom.cleanTb()
+        table_name = tdCom.getLongName(8, "letters_mixed")
+        table_name_sub = f'{table_name}_sub'
+        tb_name_lower = table_name_sub.lower()
+        tb_name_upper = table_name_sub.upper()
+        ## create stb and tb
+        tdSql.execute(f'CREATE TABLE {table_name} (ts timestamp, id int, bi1 binary(20)) tags (si1 binary(20))')
+        tdSql.execute(f'create table {table_name_sub}1 using {table_name} tags ("{table_name_sub}1")')
+        tdSql.execute(f'create table {tb_name_lower}2 using {table_name} tags ("{tb_name_lower}2")')
+        tdSql.execute(f'create table {tb_name_upper}3 using {table_name} tags ("{tb_name_upper}3")')
+        ## insert values
+        tdSql.execute(f'insert into {table_name_sub}1 values (now-1s, 1, "{table_name_sub}1")')
+        tdSql.execute(f'insert into {tb_name_lower}2 values (now-2s, 2, "{tb_name_lower}21")')
+        tdSql.execute(f'insert into {tb_name_lower}2 values (now-3s, 3, "{tb_name_lower}22")')
+        tdSql.execute(f'insert into {tb_name_upper}3 values (now-4s, 4, "{tb_name_upper}31")')
+        tdSql.execute(f'insert into {tb_name_upper}3 values (now-5s, 5, "{tb_name_upper}32")')
+        tdSql.execute(f'insert into {tb_name_upper}3 values (now-6s, 6, "{tb_name_upper}33")')
+        ## query where tbname in single
+        tdSql.query(f'select * from {table_name} where tbname in ("{table_name_sub}1")')
+        tdSql.checkRows(1)
+        tdSql.query(f'select * from {table_name} where tbname in ("{table_name_sub.upper()}1")')
+        tdSql.checkRows(1)
+        tdSql.query(f'select * from {table_name} where tbname in ("{table_name_sub.lower()}1")')
+        tdSql.checkRows(1)
+        tdSql.query(f'select * from {table_name} where tbname in ("{tb_name_lower}2")')
+        tdSql.checkRows(2)
+        tdSql.query(f'select * from {table_name} where tbname in ("{tb_name_lower.upper()}2")')
+        tdSql.checkRows(2)
+        tdSql.query(f'select * from {table_name} where tbname in ("{tb_name_upper}3")')
+        tdSql.checkRows(3)
+        tdSql.query(f'select * from {table_name} where tbname in ("{tb_name_upper.lower()}3")')
+        tdSql.checkRows(3)
+        ## query where tbname in multi
+        tdSql.query(f'select * from {table_name} where id=5 and tbname in ("{table_name_sub}1", "{tb_name_lower.upper()}2", "{tb_name_upper.lower()}3")')
+        tdSql.checkRows(1)
+        tdSql.query(f'select * from {table_name} where tbname in ("{table_name_sub}1", "{tb_name_lower.upper()}2", "{tb_name_upper.lower()}3")')
+        tdSql.checkRows(6)
+    def run(self):
+        tdSql.prepare()
+        self.checkStbWhereIn()
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
--- a/tests/pytest/query/tbname.py
+++ b/tests/pytest/query/tbname.py
@@ -53,6 +53,9 @@ class TDTestCase:
            "select * from cars where id=0 and tbname in ('carzero', 'cartwo')")
        tdSql.checkRows(1)
+        tdSql.query("select * from cars where tbname in ('carZero', 'CARONE')")
+        tdSql.checkRows(2)
        """
        tdSql.query("select * from cars where tbname like 'car%'")
        tdSql.checkRows(2)

--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
@@ -47,6 +47,7 @@ class TDTestCase:
        else:
            tdLog.info("taosd found in %s" % buildPath)
        binPath = buildPath + "/build/bin/"
        # insert: create one  or mutiple tables per sql and insert multiple rows per sql
        # insert data from a special timestamp
        # check stable stb0
@@ -89,6 +90,7 @@ class TDTestCase:
        os.system(
            "%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseNow.json -y " %
            binPath)
        tdSql.execute("use nsdb2")
        tdSql.query("show stables")
        tdSql.checkData(0, 4, 100)

--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.py
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# -*- coding: utf-8 -*-
+import random
+import string
+from util.sql import tdSql
+class TDCom:
+    def init(self, conn, logSql):
+        tdSql.init(conn.cursor(), logSql)
+    def cleanTb(self):
+        query_sql = "show stables"
+        res_row_list = tdSql.query(query_sql, True)
+        stb_list = map(lambda x: x[0], res_row_list)
+        for stb in stb_list:
+            tdSql.execute(f'drop table if exists {stb}')
+        query_sql = "show tables"
+        res_row_list = tdSql.query(query_sql, True)
+        tb_list = map(lambda x: x[0], res_row_list)
+        for tb in tb_list:
+            tdSql.execute(f'drop table if exists {tb}')
+    def getLongName(self, len, mode = "mixed"):
+        """
+            generate long name
+            mode could be numbers/letters/letters_mixed/mixed
+        """    
+        if mode == "numbers": 
+            chars = ''.join(random.choice(string.digits) for i in range(len))
+        elif mode == "letters": 
+            chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(len))
+        elif mode == "letters_mixed": 
+            chars = ''.join(random.choice(string.ascii_letters.upper() + string.ascii_letters.lower()) for i in range(len))
+        else:
+            chars = ''.join(random.choice(string.ascii_letters.lower() + string.digits) for i in range(len))
+        return chars
+    def close(self):
+        self.cursor.close()
+tdCom = TDCom()
\ No newline at end of file
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
@@ -313,6 +313,12 @@ if $rows != 6 then
  return -1
 endi
+print =============================> TD-6086
+sql create stable td6086st(ts timestamp, d double) tags(t nchar(50));
+sql create table td6086ct1 using td6086st tags("ct1");
+sql create table td6086ct2 using td6086st tags("ct2");
+sql SELECT LAST(d),t FROM td6086st WHERE tbname in ('td6086ct1', 'td6086ct2') and ts>="2019-07-30 00:00:00" and ts<="2021-08-31 00:00:00" interval(1800s) fill(prev) GROUP BY tbname;
 print ==================> td-2624
 sql create table tm2(ts timestamp, k int, b binary(12));
 sql insert into tm2 values('2011-01-02 18:42:45.326',      -1,'abc');
@@ -1149,9 +1155,11 @@ endi
 sql select derivative(test_column_alias_name, 1s, 0) from (select avg(k) test_column_alias_name from t1 interval(1s));
-sql create table smeters (ts timestamp, current float, voltage int);
+sql create table smeters (ts timestamp, current float, voltage int) tags (t1 int);
-sql insert into smeters values ('2021-08-08 10:10:10', 10, 1);
+sql create table smeter1 using smeters tags (1);
-sql insert into smeters values ('2021-08-08 10:10:12', 10, 2);
+sql insert into smeter1 values ('2021-08-08 10:10:10', 10, 2);
+sql insert into smeter1 values ('2021-08-08 10:10:12', 10, 2);
+sql insert into smeter1 values ('2021-08-08 10:10:14', 20, 1);
 sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000'  and current=10 interval(1000a);
 if $rows != 2 then
@@ -1160,9 +1168,21 @@ endi
 if $data00 != @21-08-08 10:10:10.000@ then
  return -1
 endi
+if $data01 != 0.000000000 then
+  return -1
+endi
 if $data10 != @21-08-08 10:10:12.000@ then
  return -1
 endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000'  and current=10;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 0.000000000 then
+  return -1
+endi
--- a/tests/script/general/parser/interp.sim
+++ b/tests/script/general/parser/interp.sim
@@ -68,7 +68,6 @@ print ================== server restart completed
 run general/parser/interp_test.sim
 print ================= TD-5931
 sql create stable st5931(ts timestamp, f int) tags(t int)
 sql create table ct5931 using st5931 tags(1)
@@ -76,6 +75,7 @@ sql create table nt5931(ts timestamp, f int)
 sql select interp(*) from nt5931 where ts=now
 sql select interp(*) from st5931 where ts=now
 sql select interp(*) from ct5931 where ts=now
 if $rows != 0 then
  return -1
 endi

--- a/tests/script/general/parser/interp_test.sim
+++ b/tests/script/general/parser/interp_test.sim
@@ -930,8 +930,254 @@ if $data44 != @18-11-25 19:06:00.000@ then
 endi
+sql select interp(c1) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:42:00.000' interval(1m) fill(linear);
+if $rows != 8 then
+  return -1
+endi
+if $data00 != @18-09-17 20:35:00.000@  then
+  return -1
+endi
+if $data01 != NULL  then
+  return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@  then
+  return -1
+endi
+if $data11 != NULL then
+  return -1
+endi
+if $data20 != @18-09-17 20:37:00.000@  then
+  return -1
+endi
+if $data21 != NULL then
+  return -1
+endi
+if $data30 != @18-09-17 20:38:00.000@  then
+  return -1
+endi
+if $data31 != NULL then
+  return -1
+endi
+if $data40 != @18-09-17 20:39:00.000@  then
+  return -1
+endi
+if $data41 != NULL then
+  return -1
+endi
+if $data50 != @18-09-17 20:40:00.000@  then
+  return -1
+endi
+if $data51 != 0 then
+  return -1
+endi
+if $data60 != @18-09-17 20:41:00.000@  then
+  return -1
+endi
+if $data61 != NULL then
+  return -1
+endi
+if $data70 != @18-09-17 20:42:00.000@  then
+  return -1
+endi
+if $data71 != NULL then
+  return -1
+endi
+sql select interp(c1) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:42:00.000' interval(1m) fill(linear) order by ts desc;
+if $rows != 8 then
+  return -1
+endi
+if $data00 != @18-09-17 20:42:00.000@  then
+  return -1
+endi
+if $data01 != NULL  then
+  return -1
+endi
+if $data10 != @18-09-17 20:41:00.000@  then
+  return -1
+endi
+if $data11 != NULL then
+  return -1
+endi
+if $data20 != @18-09-17 20:40:00.000@  then
+  return -1
+endi
+if $data21 != 0 then
+  return -1
+endi
+if $data30 != @18-09-17 20:39:00.000@  then
+  return -1
+endi
+if $data31 != NULL then
+  return -1
+endi
+if $data40 != @18-09-17 20:38:00.000@  then
+  return -1
+endi
+if $data41 != NULL then
+  return -1
+endi
+if $data50 != @18-09-17 20:37:00.000@  then
+  return -1
+endi
+if $data51 != NULL then
+  return -1
+endi
+if $data60 != @18-09-17 20:36:00.000@  then
+  return -1
+endi
+if $data61 != NULL then
+  return -1
+endi
+if $data70 != @18-09-17 20:35:00.000@  then
+  return -1
+endi
+if $data71 != NULL then
+  return -1
+endi
+sql  select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' interval(2m) fill(linear) order by ts;
+if $rows != 9 then
+  return -1
+endi
+if $data00 != @18-09-17 20:34:00.000@  then
+  return -1
+endi
+if $data01 != NULL  then
+  return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@  then
+  return -1
+endi
+if $data11 != NULL then
+  return -1
+endi
+if $data20 != @18-09-17 20:38:00.000@  then
+  return -1
+endi
+if $data21 != NULL then
+  return -1
+endi
+if $data30 != @18-09-17 20:40:00.000@  then
+  return -1
+endi
+if $data31 != 0.00000 then
+  return -1
+endi
+if $data40 != @18-09-17 20:42:00.000@  then
+  return -1
+endi
+if $data41 != 0.20000 then
+  return -1
+endi
+if $data50 != @18-09-17 20:44:00.000@  then
+  return -1
+endi
+if $data51 != 0.40000 then
+  return -1
+endi
+if $data60 != @18-09-17 20:46:00.000@  then
+  return -1
+endi
+if $data61 != 0.60000 then
+  return -1
+endi
+if $data70 != @18-09-17 20:48:00.000@  then
+  return -1
+endi
+if $data71 != 0.80000 then
+  return -1
+endi
+if $data80 != @18-09-17 20:50:00.000@  then
+  return -1
+endi
+if $data81 != 1.00000 then
+  return -1
+endi
+sql select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' interval(3m) fill(linear) order by ts;
+if $rows != 6 then
+  return -1
+endi
+if $data00 != @18-09-17 20:33:00.000@  then
+  return -1
+endi
+if $data01 != NULL  then
+  return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@  then
+  return -1
+endi
+if $data11 != NULL then
+  return -1
+endi
+if $data20 != @18-09-17 20:39:00.000@  then
+  return -1
+endi
+if $data21 != NULL then
+  return -1
+endi
+if $data30 != @18-09-17 20:42:00.000@  then
+  return -1
+endi
+if $data31 != 0.20000 then
+  return -1
+endi
+if $data40 != @18-09-17 20:45:00.000@  then
+  return -1
+endi
+if $data41 != 0.50000 then
+  return -1
+endi
+if $data50 != @18-09-17 20:48:00.000@  then
+  return -1
+endi
+if $data51 != 0.80000 then
+  return -1
+endi
+sql select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' interval(3m) fill(linear) order by ts desc;
+if $rows != 6 then
+  return -1
+endi
+if $data00 != @18-09-17 20:48:00.000@  then
+  return -1
+endi
+if $data01 != 0.80000 then
+  return -1
+endi
+if $data10 != @18-09-17 20:45:00.000@  then
+  return -1
+endi
+if $data11 != 0.50000 then
+  return -1
+endi
+if $data20 != @18-09-17 20:42:00.000@  then
+  return -1
+endi
+if $data21 != 0.20000 then
+  return -1
+endi
+if $data30 != @18-09-17 20:39:00.000@  then
+  return -1
+endi
+if $data31 != NULL then
+  return -1
+endi
+if $data40 != @18-09-17 20:36:00.000@  then
+  return -1
+endi
+if $data41 != NULL then
+  return -1
+endi
+if $data50 != @18-09-17 20:33:00.000@  then
+  return -1
+endi
+if $data51 != NULL  then
+  return -1
+endi

--- a/tests/script/general/parser/limit.sim
+++ b/tests/script/general/parser/limit.sim
@@ -75,4 +75,9 @@ sleep 100
 run general/parser/limit_tb.sim
 run general/parser/limit_stb.sim
+print ========> TD-6017
+sql use $db
+sql select * from (select ts, top(c1, 5) from $tb where ts >= $ts0 order by ts desc limit 3 offset 1)
+sql select * from (select ts, top(c1, 5) from $stb where ts >= $ts0 order by ts desc limit 3 offset 1)
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file
--- a/tests/script/general/parser/limit_tb.sim
+++ b/tests/script/general/parser/limit_tb.sim
@@ -355,6 +355,10 @@ sql select top(c1, 1) from $tb where ts >= $ts0 and ts <= $tsu limit 5 offset 1
 if $rows != 0 then
  return -1
 endi
+print ========> TD-6017
+sql select * from (select ts, top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1)
 sql select top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1
 print select top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1
 print $data00 $data01

--- a/tests/script/general/parser/tbnameIn_query.sim
+++ b/tests/script/general/parser/tbnameIn_query.sim
@@ -101,6 +101,30 @@ if $data11 != 2 then
  return -1
 endi
+## tbname in can accpet Upper case table name
+sql select count(*) from $stb where tbname in ('ti_tb0', 'TI_tb1', 'TI_TB2') group by t1 order by t1
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 10 then
+  return -1
+endi
+if $data01 != 0 then
+  return -1
+endi
+if $data10 != 10 then
+  return -1
+endi
+if $data11 != 1 then
+  return -1
+endi
+if $data20 != 10 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
 # multiple tbname in is not allowed NOW
 sql_error select count(*) from $stb where tbname in ('ti_tb1', 'ti_tb300') and tbname in ('ti_tb5', 'ti_tb1000') group by t1 order by t1 asc
 #if $rows != 4 then

--- a/tests/script/http/httpTest.c
+++ b/tests/script/http/httpTest.c
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <pthread.h>
+#define MAXLINE 1024
+typedef struct {
+  pthread_t pid;
+  int threadId;
+  int rows;
+  int tables;
+} ThreadObj;
+void post(char *ip,int port,char *page,char *msg) {
+    int sockfd,n;
+    char recvline[MAXLINE];
+    struct sockaddr_in servaddr;
+    char content[4096];
+    char content_page[50];
+    sprintf(content_page,"POST /%s HTTP/1.1\r\n",page);
+    char content_host[50];
+    sprintf(content_host,"HOST: %s:%d\r\n",ip,port);
+    char content_type[] = "Content-Type: text/plain\r\n";
+    char Auth[] = "Authorization: Basic cm9vdDp0YW9zZGF0YQ==\r\n";
+    char content_len[50];
+    sprintf(content_len,"Content-Length: %ld\r\n\r\n",strlen(msg));
+    sprintf(content,"%s%s%s%s%s%s",content_page,content_host,content_type,Auth,content_len,msg);
+    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0) {
+        printf("socket error\n");
+    }
+    bzero(&servaddr,sizeof(servaddr));
+    servaddr.sin_family = AF_INET;
+    servaddr.sin_port = htons(port);
+    if(inet_pton(AF_INET,ip,&servaddr.sin_addr) <= 0) {
+        printf("inet_pton error\n");
+    }   
+    if(connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0) {
+        printf("connect error\n");
+    }
+    write(sockfd,content,strlen(content));
+    printf("%s\n", content);
+    while((n = read(sockfd,recvline,MAXLINE)) > 0) {
+        recvline[n] = 0;
+        if(fputs(recvline,stdout) == EOF) {
+            printf("fputs error\n");
+        }
+    }
+    if(n < 0) {
+        printf("read error\n");
+    }
+}
+void singleThread() {
+    char ip[] = "127.0.0.1";
+    int port = 6041;
+    char page[] = "rest/sql";
+    char page1[] = "rest/sql/db1";
+    char page2[] = "rest/sql/db2";
+    char nonexit[] = "rest/sql/xxdb";
+    post(ip,port,page,"drop database if exists db1");
+    post(ip,port,page,"create database if not exists db1");
+    post(ip,port,page,"drop database if exists db2");
+    post(ip,port,page,"create database if not exists db2");
+    post(ip,port,page1,"create table t11 (ts timestamp, c1 int)");
+    post(ip,port,page2,"create table t21 (ts timestamp, c1 int)");
+    post(ip,port,page1,"insert into t11 values (now, 1)");
+    post(ip,port,page2,"insert into t21 values (now, 2)");
+    post(ip,port,nonexit,"create database if not exists db3");
+}
+void execute(void *params) {
+    char ip[] = "127.0.0.1";
+    int port = 6041;
+    char page[] = "rest/sql";
+    char *unique = calloc(1, 1024);
+    char *sql = calloc(1, 1024);
+    ThreadObj *pThread = (ThreadObj *)params;
+    printf("Thread %d started\n", pThread->threadId);
+    sprintf(unique, "rest/sql/db%d",pThread->threadId);
+    sprintf(sql, "drop database if exists db%d", pThread->threadId);
+    post(ip,port,page, sql);
+    sprintf(sql, "create database if not exists db%d", pThread->threadId);
+    post(ip,port,page, sql);
+    for (int i = 0; i < pThread->tables; i++) {
+        sprintf(sql, "create table t%d (ts timestamp, c1 int)", i);
+        post(ip,port,unique, sql);
+    }
+    for (int i = 0; i < pThread->rows; i++) {
+        sprintf(sql, "insert into t%d values (now + %ds, %d)", pThread->threadId, i, pThread->threadId);
+        post(ip,port,unique, sql);
+    }
+    free(unique);
+    free(sql);
+    return;
+}
+void multiThread() {
+    int numOfThreads = 100;
+    int numOfTables = 100;
+    int numOfRows = 1;
+    ThreadObj *threads = calloc((size_t)numOfThreads, sizeof(ThreadObj));
+    for (int i = 0; i < numOfThreads; i++) {
+        ThreadObj *pthread = threads + i;
+        pthread_attr_t thattr;
+        pthread->threadId = i + 1;
+        pthread->rows = numOfRows;
+        pthread->tables = numOfTables;
+        pthread_attr_init(&thattr);
+        pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+        pthread_create(&pthread->pid, &thattr, (void *(*)(void *))execute, pthread);
+    }
+    for (int i = 0; i < numOfThreads; i++) {
+        pthread_join(threads[i].pid, NULL);
+    }
+    free(threads);
+}
+int main() {
+    singleThread();
+    multiThread();
+    exit(0);
+}
\ No newline at end of file
--- a/tests/script/http/makefile
+++ b/tests/script/http/makefile
+all:
+	gcc -g httpTest.c -o httpTest -lpthread
\ No newline at end of file
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -90,6 +90,14 @@ cd ../../../debug; make
 ./test.sh -f general/parser/function.sim
 ./test.sh -f unique/cluster/vgroup100.sim
+./test.sh -f unique/http/admin.sim
+./test.sh -f unique/http/opentsdb.sim
+./test.sh -f unique/import/replica2.sim
+./test.sh -f unique/import/replica3.sim
+./test.sh -f general/alter/cached_schema_after_alter.sim
 #======================b1-end===============
 #======================b2-start===============