[td-225]merge develop

dc95f7b8 · Haojun Liao · a97de8dc · b45f8b24 · dc95f7b8 · dc95f7b8
118 changed file
--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -69,7 +69,6 @@ IF (TD_LINUX_32)
 ENDIF ()

 IF (TD_ARM_64)
-  ADD_DEFINITIONS(-D_M_X64)
  ADD_DEFINITIONS(-D_TD_ARM_64)
  ADD_DEFINITIONS(-D_TD_ARM_)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
@@ -86,17 +85,19 @@ IF (TD_ARM_32)
 ENDIF ()

 IF (TD_MIPS_64)
-  ADD_DEFINITIONS(-D_TD_MIPS_64_)
+  ADD_DEFINITIONS(-D_TD_MIPS_)
+  ADD_DEFINITIONS(-D_TD_MIPS_64)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "mips64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()

 IF (TD_MIPS_32)
-  ADD_DEFINITIONS(-D_TD_MIPS_32_)
+  ADD_DEFINITIONS(-D_TD_MIPS_)
+  ADD_DEFINITIONS(-D_TD_MIPS_32)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "mips32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()

 IF (TD_APLHINE)

--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
  #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
  #INSTALL(TARGETS shell RUNTIME DESTINATION .)
  IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.27-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.28-dist.jar DESTINATION connector/jdbc)
  ENDIF ()
 ELSEIF (TD_DARWIN)
  SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")

--- a/documentation20/cn/07.advanced-features/docs.md
+++ b/documentation20/cn/07.advanced-features/docs.md
@@ -120,7 +120,7 @@ if (async) {
 }
 ```

-TDengine中的订阅既可以是同步的，也可以是异步的，上面的代码会根据从命令行获取的参数`async`的值来决定使用哪种方式。这里，同步的意思是用户程序要直接调用`taos_consume`来拉取数据，而异步则由API在内部的另一个线程中调用`taos_consume`，然后把拉取到的数据交给回调函数`subscribe_callback`去处理。
+TDengine中的订阅既可以是同步的，也可以是异步的，上面的代码会根据从命令行获取的参数`async`的值来决定使用哪种方式。这里，同步的意思是用户程序要直接调用`taos_consume`来拉取数据，而异步则由API在内部的另一个线程中调用`taos_consume`，然后把拉取到的数据交给回调函数`subscribe_callback`去处理。（注意，`subscribe_callback` 中不宜做较为耗时的操作，否则有可能导致客户端阻塞等不可控的问题。）

 参数`taos`是一个已经建立好的数据库连接，在同步模式下无特殊要求。但在异步模式下，需要注意它不会被其它线程使用，否则可能导致不可预计的错误，因为回调函数在API的内部线程中被调用，而TDengine的部分API不是线程安全的。


--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -377,6 +377,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
    * res：查询结果集，注意结果集中可能没有记录
    * param：调用 `taos_subscribe`时客户程序提供的附加参数
    * code：错误码
+  **注意**：在这个回调函数里不可以做耗时过长的处理，尤其是对于返回的结果集中数据较多的情况，否则有可能导致客户端阻塞等异常状态。如果必须进行复杂计算，则建议在另外的线程中进行处理。

 * `TAOS_RES *taos_consume(TAOS_SUB *tsub)`


--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -144,7 +144,7 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
 - numOfMnodes：系统中管理节点个数。默认值：3。
 - balance：是否启动负载均衡。0：否，1：是。默认值：1。
 - mnodeEqualVnodeNum: 一个mnode等同于vnode消耗的个数。默认值：4。
- offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*10（即10天）。
+- offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*100（即100天）。
 - statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
 - maxTablesPerVnode: 每个vnode中能够创建的最大表个数。默认值：1000000。
 - maxVgroupsPerDb: 每个数据库中能够使用的最大vgroup个数。

--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -48,15 +48,15 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
 | 3    |  BIGINT   | 8      | 长整型，范围 [-2^63+1,   2^63-1], -2^63 用于 NULL                                 |
 | 4    |   FLOAT   | 4      | 浮点型，有效位数 6-7，范围 [-3.4E38, 3.4E38]                  |
 | 5    |  DOUBLE   | 8      | 双精度浮点型，有效位数 15-16，范围 [-1.7E308, 1.7E308]      |
-| 6    |  BINARY   | 自定义 | 用于记录 ASCII 型字符串。理论上，最长可以有 16374 字节，但由于每行数据最多 16K 字节，实际上限一般小于理论值。 binary 仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如 binary(20) 定义了最长为 20 个字符的字符串，每个字符占 1 byte 的存储空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\’`。 |
+| 6    |  BINARY   | 自定义 | 记录二进制字节型字符串，建议只用于处理 ASCII 可见字符，中文等多字节字符需使用 nchar。理论上，最长可以有 16374 字节，但由于每行数据最多 16K 字节，实际上限一般小于理论值。binary 仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如 binary(20) 定义了最长为 20 个字节型字符的字符串，每个字节型字符占 1 byte 的存储空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\’`。 |
 | 7    | SMALLINT  | 2      | 短整型， 范围 [-32767, 32767], -32768 用于 NULL                                |
 | 8    |  TINYINT  | 1      | 单字节整型，范围 [-127, 127], -128 用于 NULL                                |
 | 9    |   BOOL    | 1      | 布尔型，{true, false}                                      |
-| 10   |   NCHAR   | 自定义 | 用于记录非 ASCII 型字符串，如中文字符。每个 nchar 字符占用 4 bytes 的存储空间。字符串两端使用单引号引用，字符串内的单引号需用转义字符 `\’`。nchar 使用时须指定字符串大小，类型为 nchar(10) 的列表示此列的字符串最多存储 10 个 nchar 字符，会固定占用 40 bytes 的空间。如果用户字符串长度超出声明长度，将会报错。 |
+| 10   |   NCHAR   | 自定义 | 记录包含多字节字符在内的字符串，如中文字符。每个 nchar 字符占用 4 bytes 的存储空间。字符串两端使用单引号引用，字符串内的单引号需用转义字符 `\’`。nchar 使用时须指定字符串大小，类型为 nchar(10) 的列表示此列的字符串最多存储 10 个 nchar 字符，会固定占用 40 bytes 的空间。如果用户字符串长度超出声明长度，将会报错。 |

 **Tips**:
 1. TDengine 对 SQL 语句中的英文字符不区分大小写，自动转化为小写执行。因此用户大小写敏感的字符串及密码，需要使用单引号将字符串引起来。
-2. 应避免使用 BINARY 类型来保存非 ASCII 型的字符串，会很容易导致数据乱码等错误。正确的做法是使用 NCHAR 类型来保存中文字符。
+2. **注意**，虽然 Binary 类型在底层存储上支持字节型的二进制字符，但不同编程语言对二进制数据的处理方式并不保证一致，因此建议在 Binary 类型中只存储 ASCII 可见字符，而避免存储不可见字符。多字节的数据，例如中文字符，则需要使用 nchar 类型进行保存。如果强行使用 Binary 类型保存中文字符，虽然有时也能正常读写，但并不带有字符集信息，很容易出现数据乱码甚至数据损坏。

 ## <a class="anchor" id="management"></a>数据库管理


--- a/documentation20/cn/13.faq/docs.md
+++ b/documentation20/cn/13.faq/docs.md
@@ -102,7 +102,7 @@ TDengine 目前尚不支持删除功能，未来根据用户需求可能会支

 批量插入。每条写入语句可以一张表同时插入多条记录，也可以同时插入多张表的多条记录。

-## 12. 最有效的写入数据的方法是什么？windows系统下插入的nchar类数据中的汉字被解析成了乱码如何解决？
+## 12. windows系统下插入的nchar类数据中的汉字被解析成了乱码如何解决？

 Windows下插入nchar类的数据中如果有中文，请先确认系统的地区设置成了中国（在Control Panel里可以设置），这时cmd中的`taos`客户端应该已经可以正常工作了；如果是在IDE里开发Java应用，比如Eclipse， Intellij，请确认IDE里的文件编码为GBK（这是Java默认的编码类型），然后在生成Connection时，初始化客户端的配置，具体语句如下：
 ```JAVA

--- a/src/client/inc/tscLocalMerge.h
+++ b/src/client/inc/tscLocalMerge.h
@@ -44,24 +44,15 @@ typedef struct SLocalMerger {
  int32_t                numOfCompleted;
  int32_t                numOfVnode;
  SLoserTreeInfo *       pLoserTree;
-  char *                 prevRowOfInput;
  tFilePage *            pResultBuf;
  int32_t                nResultBufSize;
  tFilePage *            pTempBuffer;
  struct SQLFunctionCtx *pCtx;
  int32_t                rowSize;      // size of each intermediate result.
-  bool                   hasPrevRow;   // cannot be released
-  bool                   hasUnprocessedRow;
  tOrderDescriptor *     pDesc;
  SColumnModel *         resColModel;
  SColumnModel*          finalModel;
  tExtMemBuffer **       pExtMemBuffer;      // disk-based buffer
-  SFillInfo*             pFillInfo;          // interpolation support structure
-  char*                  pFinalRes;          // result data after interpo
-  tFilePage*             discardData;
-  bool                   discard;
-  int32_t                offset;             // limit offset value
-  bool                   orderPrjOnSTable;   // projection query on stable
 } SLocalMerger;

 typedef struct SRetrieveSupport {
@@ -94,7 +85,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde

 void tscDestroyLocalMerger(SSqlObj *pSql);

-int32_t tscDoLocalMerge(SSqlObj *pSql);
+//int32_t tscDoLocalMerge(SSqlObj *pSql);

 #ifdef __cplusplus
 }

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -85,15 +85,13 @@ typedef struct SMergeTsCtx {
  int8_t          compared;
 }SMergeTsCtx;

-
 typedef struct SVgroupTableInfo {
  SVgroupInfo vgInfo;
-  SArray*     itemList;   //SArray<STableIdInfo>
+  SArray     *itemList;   // SArray<STableIdInfo>
 } SVgroupTableInfo;

-static FORCE_INLINE SQueryInfo* tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex) {
+static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex) {
  assert(pCmd != NULL && subClauseIndex >= 0);
-
  if (pCmd->pQueryInfo == NULL || subClauseIndex >= pCmd->numOfClause) {
    return NULL;
  }
@@ -101,6 +99,8 @@ static FORCE_INLINE SQueryInfo* tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t sub
  return pCmd->pQueryInfo[subClauseIndex];
 }

+SQueryInfo* tscGetActiveQueryInfo(SSqlCmd* pCmd);
+
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, SName* name, STableMeta* pTableMeta, STableDataBlocks** dataBlocks);
 void tscDestroyDataBlock(STableDataBlocks* pDataBlock, bool removeMeta);
 void tscSortRemoveDataBlockDupRows(STableDataBlocks* dataBuf);
@@ -130,7 +130,13 @@ bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
 bool tscIsSecondStageQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);
 bool tscGroupbyColumn(SQueryInfo* pQueryInfo);
-bool tscIsTopbotQuery(SQueryInfo* pQueryInfo);
+bool tscIsTopBotQuery(SQueryInfo* pQueryInfo);
+bool hasTagValOutput(SQueryInfo* pQueryInfo);
+bool timeWindowInterpoRequired(SQueryInfo *pQueryInfo);
+bool isStabledev(SQueryInfo* pQueryInfo);
+bool isTsCompQuery(SQueryInfo* pQueryInfo);
+bool isSimpleAggregate(SQueryInfo* pQueryInfo);
+bool isBlockDistQuery(SQueryInfo* pQueryInfo);
 int32_t tscGetTopbotQueryParam(SQueryInfo* pQueryInfo);

 bool tscNonOrderedProjectionQueryOnSTable(SSqlCmd *pCmd, SQueryInfo *pQueryInfo, int32_t tableIndex);
@@ -144,7 +150,7 @@ bool tscQueryTags(SQueryInfo* pQueryInfo);
 bool tscMultiRoundQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryBlockInfo(SQueryInfo* pQueryInfo);

-SSqlExpr* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
+SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType);

 int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pzTableName, SSqlObj* pSql);
@@ -175,27 +181,29 @@ void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes)

 int32_t   tscGetResRowLength(SArray* pExprList);

-SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
    int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);

-SSqlExpr* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                           int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);

-SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
+SExprInfo* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                           int16_t size);
 size_t   tscSqlExprNumOfExprs(SQueryInfo* pQueryInfo);
-void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
+void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);

-SSqlExpr* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
+SExprInfo* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
 int32_t   tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
+void      tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src);
 void      tscSqlExprInfoDestroy(SArray* pExprInfo);

 SColumn* tscColumnClone(const SColumn* src);
-bool tscColumnExists(SArray* pColumnList, SColumnIndex* pColIndex);
-SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
-SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
+bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
+SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
 void tscColumnListDestroy(SArray* pColList);

+void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+
 void tscDequoteAndTrimToken(SStrToken* pToken);
 int32_t tscValidateName(SStrToken* pToken);

@@ -217,8 +225,11 @@ bool tscShouldBeFreed(SSqlObj* pSql);
 STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
 STableMetaInfo* tscGetMetaInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);

-SQueryInfo *tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex);
-SQueryInfo *tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex);
+void        tscInitQueryInfo(SQueryInfo* pQueryInfo);
+void        tscClearSubqueryInfo(SSqlCmd* pCmd);
+int32_t     tscAddQueryInfo(SSqlCmd *pCmd);
+SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex);
+SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd, int32_t subClauseIndex);

 void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo);

@@ -226,11 +237,7 @@ STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, SName* name, STableM
                                    SVgroupsInfo* vgroupList, SArray* pTagCols, SArray* pVgroupTables);

 STableMetaInfo* tscAddEmptyMetaInfo(SQueryInfo *pQueryInfo);
-int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
-
-void tscInitQueryInfo(SQueryInfo* pQueryInfo);

-void tscClearSubqueryInfo(SSqlCmd* pCmd);
 void tscFreeVgroupTableInfo(SArray* pVgroupTables);
 SArray* tscVgroupTableInfoDup(SArray* pVgroupTables);
 void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index);
@@ -243,6 +250,8 @@ int32_t tscGetUdfFromNode(SSqlObj *pSql);

 void tscResetForNextRetrieve(SSqlRes* pRes);
 void tscDoQuery(SSqlObj* pSql);
+void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
+void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);

 SVgroupsInfo* tscVgroupInfoClone(SVgroupsInfo *pInfo);
 void* tscVgroupInfoClear(SVgroupsInfo *pInfo);
@@ -276,7 +285,7 @@ void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid);
 int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId);

-void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex);
+void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex);

 bool hasMoreVnodesToTry(SSqlObj *pSql);
 bool hasMoreClauseToTry(SSqlObj* pSql);
@@ -301,7 +310,10 @@ CChildTableMeta* tscCreateChildMeta(STableMeta* pTableMeta);
 uint32_t tscGetTableMetaMaxSize();
 int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name);
 STableMeta* tscTableMetaDup(STableMeta* pTableMeta);
+int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr);

+void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema);
+void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo, SOperatorInfo* pOperator, char* sql, void* addr, int32_t stage);

 void* malloc_throw(size_t size);
 void* calloc_throw(size_t nmemb, size_t size);

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -35,6 +35,7 @@ extern "C" {
 #include "qExecutor.h"
 #include "qSqlparser.h"
 #include "qTsbuf.h"
+#include "qUtil.h"
 #include "tcmdtype.h"

 // forward declaration
@@ -96,56 +97,29 @@ typedef struct STableMetaInfo {
  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
 } STableMetaInfo;

-
 typedef struct SColumnIndex {
  int16_t tableIndex;
  int16_t columnIndex;
 } SColumnIndex;

-
-typedef struct SFieldInfo {
-  int16_t      numOfOutput;   // number of column in result
-  TAOS_FIELD*  final;
-  SArray      *internalField; // SArray<SInternalField>
-} SFieldInfo;
-
 typedef struct SColumn {
-  SColumnIndex       colIndex;
-  int32_t            numOfFilters;
-  SColumnFilterInfo *filterInfo;
+  uint64_t     tableUid;
+  int32_t      columnIndex;
+  SColumnInfo  info;
 } SColumn;

-/* the structure for sql function in select clause */
-typedef struct SSqlExpr {
-  char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
-  SColIndex colInfo;
-  uint64_t  uid;            // refactor use the pointer
-  int16_t   functionId;     // function id in aAgg array
-  int16_t   resType;        // return value type
-  int16_t   resBytes;       // length of return value
-  int32_t   interBytes;     // inter result buffer size
-  int16_t   numOfParams;    // argument value of each function
-  tVariant  param[3];       // parameters are not more than 3
-  int32_t   offset;         // sub result column value of arithmetic expression.
-  int16_t   resColId;       // result column id
-  SColumn  *pFilter;        // expr filter
-} SSqlExpr;
-
-typedef struct SExprFilter {
-  tSqlExpr       *pExpr;     //used for having parse
-  SSqlExpr       *pSqlExpr;
-  SArray         *fp;
-  SColumn        *pFilters;  //having filter info
-}SExprFilter;
-
 typedef struct SInternalField {
  TAOS_FIELD      field;
  bool            visible;
-  SExprInfo      *pArithExprInfo;
-  SSqlExpr       *pSqlExpr;
-  SExprFilter    *pFieldFilters;
+  SExprInfo      *pExpr;
 } SInternalField;

+typedef struct SFieldInfo {
+  int16_t      numOfOutput;   // number of column in result
+  TAOS_FIELD*  final;
+  SArray      *internalField; // SArray<SInternalField>
+} SFieldInfo;
+
 typedef struct SCond {
  uint64_t uid;
  int32_t  len;  // length of tag query condition data
@@ -229,13 +203,14 @@ typedef struct SQueryInfo {
  SInterval        interval;      // tumble time window
  SSessionWindow   sessionWindow; // session time window

-  SSqlGroupbyExpr  groupbyExpr;   // group by tags info
+  SSqlGroupbyExpr  groupbyExpr;   // groupby tags info
  SArray *         colList;       // SArray<SColumn*>
  SFieldInfo       fieldsInfo;
-  SArray *         exprList;      // SArray<SSqlExpr*>
+  SArray *         exprList;      // SArray<SExprInfo*>
  SLimitVal        limit;
  SLimitVal        slimit;
  STagCond         tagCond;
+
  SOrderVal        order;
  int16_t          fillType;      // final result fill type
  int16_t          numOfTables;
@@ -254,7 +229,17 @@ typedef struct SQueryInfo {
  int32_t          round;         // 0/1/....
  int32_t          bufLen;
  char*            buf;
+  SQInfo*          pQInfo;         // global merge operator
+  SArray*          pDSOperator;    // data source operator
+  SArray*          pPhyOperator;   // physical query execution plan
+  SQueryAttr*      pQueryAttr;     // query object
+
+  struct SQueryInfo *sibling;     // sibling
+  SArray            *pUpstream;   // SArray<struct SQueryInfo>
+  struct SQueryInfo *pDownstream;
  int32_t            havingFieldNum;
+  bool               globalMerge; // need global merge
+  bool               arithmCalOnAgg; // arithmetic calculation on aggregate result.
 } SQueryInfo;

 typedef struct {
@@ -270,8 +255,6 @@ typedef struct {
  };

  uint32_t     insertType;   // TODO remove it
-  int32_t      clauseIndex;  // index of multiple subclause query
-
  char *       curSql;       // current sql, resume position of sql after parsing paused
  int8_t       parseFinished;
  char         reserve2[3];        // fix bus error on arm32
@@ -281,8 +264,12 @@ typedef struct {
  uint32_t     allocSize;
  char *       payload;
  int32_t      payloadLen;
+
  SQueryInfo **pQueryInfo;
  int32_t      numOfClause;
+  int32_t      clauseIndex;  // index of multiple subclause query
+  SQueryInfo  *active;       // current active query info
+
  int32_t      batchSize;    // for parameter ('?') binding and batch processing
  int32_t      numOfParams;

@@ -440,7 +427,7 @@ void tscInitMsgsFp();
 int tsParseSql(SSqlObj *pSql, bool initial);

 void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet);
-int  tscProcessSql(SSqlObj *pSql);
+int  tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo);

 int  tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex);
 void tscAsyncResultOnError(SSqlObj *pSql);
@@ -455,6 +442,9 @@ void    tscRestoreFuncForSTableQuery(SQueryInfo *pQueryInfo);

 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock);
+
+void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 void destroyTableNameList(SSqlCmd* pCmd);

 void tscResetSqlCmd(SSqlCmd *pCmd, bool removeMeta);
@@ -502,47 +492,6 @@ int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* s

 int32_t tscToSQLCmd(SSqlObj *pSql, struct SSqlInfo *pInfo);

-static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pFieldInfo, int32_t columnIndex, int32_t offset) {
-  SInternalField* pInfo = (SInternalField*) TARRAY_GET_ELEM(pFieldInfo->internalField, columnIndex);
-
-  int32_t type = pInfo->field.type;
-  int32_t bytes = pInfo->field.bytes;
-
-  char* pData = pRes->data + (int32_t)(offset * pRes->numOfRows + bytes * pRes->row);
-  UNUSED(pData);
-
-//   user defined constant value output columns
-  if (pInfo->pSqlExpr != NULL && TSDB_COL_IS_UD_COL(pInfo->pSqlExpr->colInfo.flag)) {
-    if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
-      pData = pInfo->pSqlExpr->param[1].pz;
-      pRes->length[columnIndex] = pInfo->pSqlExpr->param[1].nLen;
-      pRes->tsrow[columnIndex] = (pInfo->pSqlExpr->param[1].nType == TSDB_DATA_TYPE_NULL) ? NULL : (unsigned char*)pData;
-    } else {
-      assert(bytes == tDataTypes[type].bytes);
-
-      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : (unsigned char*)&pInfo->pSqlExpr->param[1].i64;
-      pRes->length[columnIndex] = bytes;
-    }
-  } else {
-    if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
-      int32_t realLen = varDataLen(pData);
-      assert(realLen <= bytes - VARSTR_HEADER_SIZE);
-
-      pRes->tsrow[columnIndex] = (isNull(pData, type)) ? NULL : (unsigned char*)((tstr *)pData)->data;
-      if (realLen < pInfo->pSqlExpr->resBytes - VARSTR_HEADER_SIZE) {  // todo refactor
-        *(pData + realLen + VARSTR_HEADER_SIZE) = 0;
-      }
-
-      pRes->length[columnIndex] = realLen;
-    } else {
-      assert(bytes == tDataTypes[type].bytes);
-
-      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : (unsigned char*)pData;
-      pRes->length[columnIndex] = bytes;
-    }
-  }
-}
-
 extern int32_t    sentinel;
 extern SHashObj  *tscVgroupMap;
 extern SHashObj  *tscTableMetaInfo;

--- a/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
+++ b/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
@@ -49,6 +49,14 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset
  (JNIEnv *, jclass);

+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    getResultTimePrecision
+ * Signature: (J)J
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecision
+        (JNIEnv *, jobject, jlong, jlong);
+
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    connectImp

--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -671,3 +671,20 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTab
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset(JNIEnv *env, jobject jobj) {
  return (*env)->NewStringUTF(env, (const char *)tsCharset);
 }
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecision(JNIEnv *env, jobject jobj, jlong con,
+                                                                                      jlong res) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection is closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_RES *result = (TAOS_RES *)res;
+  if (result == NULL) {
+    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
+    return JNI_RESULT_SET_NULL;
+  }
+
+  return taos_result_precision(result);
+}
\ No newline at end of file
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -57,7 +57,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para

  strntolower(pSql->sqlstr, sqlstr, (int32_t)sqlLen);

-  tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
+  tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
  pCmd->curSql = pSql->sqlstr;

  int32_t code = tsParseSql(pSql, true);
@@ -69,7 +69,8 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
    return;
  }

-  tscDoQuery(pSql);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  executeQuery(pSql, pQueryInfo);
 }

 // TODO return the correct error code to client in tscQueueAsyncError
@@ -179,7 +180,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
  if (pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE) {
    tscFetchDatablockForSubquery(pSql);
  } else {
-    tscProcessSql(pSql);
+    tscBuildAndSendRequest(pSql, NULL);
  }
 }

@@ -193,8 +194,8 @@ static void tscAsyncQueryRowsForNextVnode(void *param, TAOS_RES *tres, int numOf
  tscProcessAsyncRetrieveImpl(param, tres, numOfRows, tscAsyncFetchRowsProxy);
 }

-void taos_fetch_rows_a(TAOS_RES *taosa, __async_cb_func_t fp, void *param) {
-  SSqlObj *pSql = (SSqlObj *)taosa;
+void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
+  SSqlObj *pSql = (SSqlObj *)tres;
  if (pSql == NULL || pSql->signature != pSql) {
    tscError("sql object is NULL");
    tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED);
@@ -207,17 +208,15 @@ void taos_fetch_rows_a(TAOS_RES *taosa, __async_cb_func_t fp, void *param) {
  // user-defined callback function is stored in fetchFp
  pSql->fetchFp = fp;
  pSql->fp      = tscAsyncFetchRowsProxy;
+  pSql->param   = param;

  if (pRes->qId == 0) {
-    tscError("qhandle is NULL");
+    tscError("qhandle is invalid");
    pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;
-    pSql->param = param;
-
    tscAsyncResultOnError(pSql);
    return;
  }

-  pSql->param = param;
  tscResetForNextRetrieve(pRes);
  
  // handle the sub queries of join query
@@ -256,7 +255,8 @@ void taos_fetch_rows_a(TAOS_RES *taosa, __async_cb_func_t fp, void *param) {
      pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
    }

-    tscProcessSql(pSql);
+    SQueryInfo* pQueryInfo1 = tscGetActiveQueryInfo(&pSql->cmd);
+    tscBuildAndSendRequest(pSql, pQueryInfo1);
  }
 }

@@ -283,7 +283,7 @@ void tscQueueAsyncError(void(*fp), void *param, int32_t code) {
 static void tscAsyncResultCallback(SSchedMsg *pMsg) {
  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pMsg->ahandle);
  if (pSql == NULL || pSql->signature != pSql) {
-    tscDebug("%p SqlObj is freed, not add into queue async res", pSql);
+    tscDebug("%p SqlObj is freed, not add into queue async res", pMsg->ahandle);
    return;
  }

@@ -323,7 +323,7 @@ static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableM

    SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
    for (int32_t i = 0; i < numOfExprs; ++i) {
-      SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
+      SSqlExpr *pExpr = &(tscSqlExprGet(pQueryInfo, i)->base);
      pExpr->uid = pTableMetaInfo->pTableMeta->id.uid;

      if (pExpr->colInfo.colIndex >= 0) {
@@ -344,7 +344,7 @@ static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableM
    // validate the table columns information
    for (int32_t i = 0; i < taosArrayGetSize(pQueryInfo->colList); ++i) {
      SColumn *pCol = taosArrayGetP(pQueryInfo->colList, i);
-      if (pCol->colIndex.columnIndex >= numOfCols) {
+      if (pCol->columnIndex >= numOfCols) {
        return pSql->retryReason;
      }
    }
@@ -372,13 +372,13 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    goto _error;
  }

-  tscDebug("%p get %s successfully", pSql, msg);
+  tscDebug("0x%"PRIx64" get %s successfully", pSql->self, msg);
  if (pSql->pStream == NULL) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);

    // check if it is a sub-query of super table query first, if true, enter another routine
    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
-      tscDebug("%p update local table meta, continue to process sql and send the corresponding query", pSql);
+      tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send the corresponding query", pSql->self);

      STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

@@ -396,13 +396,13 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
        goto _error;
      }

-      // tscProcessSql can add error into async res
-      tscProcessSql(pSql);
+      // tscBuildAndSendRequest can add error into async res
+      tscBuildAndSendRequest(pSql, NULL);
      taosReleaseRef(tscObjRef, pSql->self);
      return;
    } else {  // continue to process normal async query
      if (pCmd->parseFinished) {
-        tscDebug("%p update local table meta, continue to process sql and send corresponding query", pSql);
+        tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send corresponding query", pSql->self);

        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
        code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -416,7 +416,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
        assert(pCmd->command != TSDB_SQL_INSERT);

        if (pCmd->command == TSDB_SQL_SELECT) {
-          tscDebug("%p redo parse sql string and proceed", pSql);
+          tscDebug("0x%"PRIx64" redo parse sql string and proceed", pSql->self);
          pCmd->parseFinished = false;
          tscResetSqlCmd(pCmd, true);

@@ -428,15 +428,15 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
            goto _error;
          }

-          tscProcessSql(pSql);
+          tscBuildAndSendRequest(pSql, NULL);
        } else {  // in all other cases, simple retry
-          tscProcessSql(pSql);
+          tscBuildAndSendRequest(pSql, NULL);
        }

        taosReleaseRef(tscObjRef, pSql->self);
        return;
      } else {
-        tscDebug("%p continue parse sql after get table meta", pSql);
+        tscDebug("0x%"PRIx64" continue parse sql after get table meta", pSql->self);

        code = tsParseSql(pSql, false);
        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -447,7 +447,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
        }

        if (pCmd->insertType == TSDB_QUERY_TYPE_STMT_INSERT) {
-          STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+          STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
          code = tscGetTableMeta(pSql, pTableMetaInfo);
          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
            taosReleaseRef(tscObjRef, pSql->self);
@@ -457,11 +457,19 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
          }

          (*pSql->fp)(pSql->param, pSql, code);
-          taosReleaseRef(tscObjRef, pSql->self);
-          return;
+        } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
+          if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
+            tscImportDataFromFile(pSql);
+          } else {
+            tscHandleMultivnodeInsert(pSql);
+          }
+        } else {
+          SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+          executeQuery(pSql, pQueryInfo1);
        }

-        // proceed to invoke the tscDoQuery();
+        taosReleaseRef(tscObjRef, pSql->self);
+        return;
      }
    }

@@ -486,7 +494,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      }
    }

-    tscDebug("%p stream:%p meta is updated, start new query, command:%d", pSql, pSql->pStream, pSql->cmd.command);
+    tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pSql->cmd.command);
    if (!pSql->cmd.parseFinished) {
      tsParseSql(pSql, false);
    }
@@ -498,7 +506,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    return;
  }

-  tscDoQuery(pSql);
+//  tscDoQuery(pSql);

  taosReleaseRef(tscObjRef, pSql->self);
  

--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -53,7 +53,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
  SSqlRes *pRes = &pSql->res;

  // one column for each row
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -154,14 +154,14 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  
  pSql->cmd.numOfCols = numOfCols;

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  pQueryInfo->order.order = TSDB_ORDER_ASC;

  TAOS_FIELD f = {.type = TSDB_DATA_TYPE_BINARY, .bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE};
  tstrncpy(f.name, "Field", sizeof(f.name));
  
  SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
      (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE, -1000, (TSDB_COL_NAME_LEN - 1), false);
  
  rowLen += ((TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE);
@@ -171,7 +171,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  tstrncpy(f.name, "Type", sizeof(f.name));
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
      -1000, typeColLength, false);
  
  rowLen += typeColLength + VARSTR_HEADER_SIZE;
@@ -181,7 +181,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  tstrncpy(f.name, "Length", sizeof(f.name));
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
      -1000, sizeof(int32_t), false);
  
  rowLen += sizeof(int32_t);
@@ -191,7 +191,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
  tstrncpy(f.name, "Note", sizeof(f.name));
  
  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
      -1000, noteColLength, false);
  
  rowLen += noteColLength + VARSTR_HEADER_SIZE;
@@ -199,7 +199,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
 }

 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  
  assert(tscGetMetaInfo(pQueryInfo, 0)->pTableMeta != NULL);

@@ -389,7 +389,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
  SColumnIndex index = {0};
  pSql->cmd.numOfCols = 2;

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  pQueryInfo->order.order = TSDB_ORDER_ASC;

  TAOS_FIELD f; 
@@ -404,7 +404,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
  } 

  SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);

  rowLen += f.bytes; 

@@ -417,7 +417,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
  }

  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, 
+  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
      (int16_t)(ddlLen + VARSTR_HEADER_SIZE), -1000, ddlLen, false);

  rowLen += ddlLen + VARSTR_HEADER_SIZE;
@@ -427,7 +427,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
 static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const char *tableName, const char *ddl) {
  SSqlRes *pRes = &pSql->res;

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  int32_t numOfRows = 1;
  if (strlen(ddl) == 0) {
    
@@ -444,7 +444,7 @@ static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const c
  return 0;
 }
 static int32_t tscSCreateBuildResult(SSqlObj *pSql, BuildType type, const char *str, const char *result) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0); 
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  int32_t rowLen = tscSCreateBuildResultFields(pSql, type, result);

  tscFieldInfoUpdateOffset(pQueryInfo);
@@ -552,7 +552,7 @@ static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
  return TSDB_CODE_SUCCESS;
 }  
 static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);

  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -606,7 +606,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
 }

 static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;

@@ -633,7 +633,7 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
 }
 static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName, char *ddl) {
  char *result = ddl;
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;

@@ -674,7 +674,7 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
 }

 static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  assert(pTableMetaInfo->pTableMeta != NULL);

@@ -700,7 +700,7 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
 }

 static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);

  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

@@ -727,7 +727,7 @@ static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
  return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
 }
 static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);

  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
  pExpr->resBytes = TSDB_USER_LEN + TSDB_DATA_TYPE_BINARY;
@@ -754,7 +754,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
  extractDBName(pSql->pTscObj->db, db);
  pthread_mutex_unlock(&pSql->pTscObj->mutex);

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);

  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
  pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -781,7 +781,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {

 static int32_t tscProcessServerVer(SSqlObj *pSql) {
  const char* v = pSql->pTscObj->sversion;
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);

  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
  pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -804,7 +804,7 @@ static int32_t tscProcessServerVer(SSqlObj *pSql) {
 }

 static int32_t tscProcessClientVer(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);

  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
  pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -856,7 +856,7 @@ static int32_t tscProcessServStatus(SSqlObj *pSql) {
    return pSql->res.code;
  }

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);

  int32_t val = 1;
@@ -870,7 +870,7 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa

  pCmd->numOfCols = 1;

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
  pQueryInfo->order.order = TSDB_ORDER_ASC;

  tscFieldInfoClear(&pQueryInfo->fieldsInfo);
@@ -882,7 +882,7 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
  tscInitResObjForLocalQuery(pSql, 1, (int32_t)valueLength);

  SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, 0);
-  pInfo->pSqlExpr = taosArrayGetP(pQueryInfo->exprList, 0);
+  pInfo->pExpr = taosArrayGetP(pQueryInfo->exprList, 0);

  memcpy(pRes->data, val, pInfo->field.bytes);
 }

--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -748,7 +748,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
  const int32_t STABLE_INDEX = 1;
  
  SSqlCmd *   pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);

  char *sql = *sqlstr;

@@ -829,6 +829,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
    index = 0;
    sToken = tStrGetToken(sql, &index, false);
    if (sToken.type != TK_TAGS && sToken.type != TK_LP) {
+      tscDestroyBoundColumnInfo(&spd);
      return tscInvalidSQLErrMsg(pCmd->payload, "keyword TAGS expected", sToken.z);
    }

@@ -841,6 +842,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
      char* end = NULL;
      code = parseBoundColumns(pCmd, &spd, pTagSchema, sql, &end);
      if (code != TSDB_CODE_SUCCESS) {
+        tscDestroyBoundColumnInfo(&spd);
        return code;
      }

@@ -858,11 +860,13 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
    sql += index;

    if (sToken.type != TK_LP) {
+      tscDestroyBoundColumnInfo(&spd);
      return tscInvalidSQLErrMsg(pCmd->payload, "( is expected", sToken.z);
    }
    
    SKVRowBuilder kvRowBuilder = {0};
    if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
+      tscDestroyBoundColumnInfo(&spd);
      return TSDB_CODE_TSC_OUT_OF_MEMORY;
    }

@@ -875,6 +879,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC

      if (TK_ILLEGAL == sToken.type) {
        tdDestroyKVRowBuilder(&kvRowBuilder);
+        tscDestroyBoundColumnInfo(&spd);
        return TSDB_CODE_TSC_INVALID_SQL;
      }

@@ -892,6 +897,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
      code = tsParseOneColumn(pSchema, &sToken, tagVal, pCmd->payload, &sql, false, tinfo.precision);
      if (code != TSDB_CODE_SUCCESS) {
        tdDestroyKVRowBuilder(&kvRowBuilder);
+        tscDestroyBoundColumnInfo(&spd);
        return code;
      }

@@ -1065,7 +1071,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
  int32_t totalNum = 0;
  int32_t code = TSDB_CODE_SUCCESS;

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
  assert(pQueryInfo != NULL);

  STableMetaInfo *pTableMetaInfo = (pQueryInfo->numOfTables == 0)? tscAddEmptyMetaInfo(pQueryInfo):tscGetMetaInfo(pQueryInfo, 0);
@@ -1089,7 +1095,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
    str = pCmd->curSql;
  }
  
-  tscDebug("%p create data block list hashList:%p", pSql, pCmd->pTableBlockHashList);
+  tscDebug("0x%"PRIx64" create data block list hashList:%p", pSql->self, pCmd->pTableBlockHashList);

  while (1) {
    int32_t   index = 0;
@@ -1285,7 +1291,7 @@ int tsInsertInitialCheck(SSqlObj *pSql) {
  pCmd->count = 0;
  pCmd->command = TSDB_SQL_INSERT;

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);

  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT | pCmd->insertType);

@@ -1303,7 +1309,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
  SSqlCmd* pCmd = &pSql->cmd;

  if ((!pCmd->parseFinished) && (!initial)) {
-    tscDebug("%p resume to parse sql: %s", pSql, pCmd->curSql);
+    tscDebug("0x%"PRIx64" resume to parse sql: %s", pSql->self, pCmd->curSql);
  }

  ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
@@ -1375,7 +1381,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
    return code;
  }

-  return tscProcessSql(pSql);
+  return tscBuildAndSendRequest(pSql, NULL);
 }

 typedef struct SImportFileSupport {
@@ -1521,6 +1527,7 @@ void tscImportDataFromFile(SSqlObj *pSql) {
  }

  assert(pCmd->dataSourceType == DATA_FROM_DATA_FILE  && strlen(pCmd->payload) != 0);
+  pCmd->active = pCmd->pQueryInfo[0];

  SImportFileSupport *pSupporter = calloc(1, sizeof(SImportFileSupport));
  SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);

--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -815,7 +815,7 @@ static int insertStmtExecute(STscStmt* stmt) {
  pRes->numOfRows  = 0;
  pRes->numOfTotal = 0;

-  tscProcessSql(pSql);
+  tscBuildAndSendRequest(pSql, NULL);

  // wait for the callback function to post the semaphore
  tsem_wait(&pSql->rspSem);

--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -61,7 +61,7 @@ void tscAddIntoSqlList(SSqlObj *pSql) {
  pSql->stime = taosGetTimestampMs();
  pSql->listed = 1;

-  tscDebug("%p added into sqlList", pSql);
+  tscDebug("0x%"PRIx64" added into sqlList", pSql->self);
 }

 void tscSaveSlowQueryFpCb(void *param, TAOS_RES *result, int code) {
@@ -99,7 +99,7 @@ void tscSaveSlowQuery(SSqlObj *pSql) {
    return;
  }

-  tscDebug("%p query time:%" PRId64 " sql:%s", pSql, pSql->res.useconds, pSql->sqlstr);
+  tscDebug("0x%"PRIx64" query time:%" PRId64 " sql:%s", pSql->self, pSql->res.useconds, pSql->sqlstr);
  int32_t sqlSize = (int32_t)(TSDB_SLOW_QUERY_SQL_LEN + size);
  
  char *sql = malloc(sqlSize);
@@ -141,7 +141,7 @@ void tscRemoveFromSqlList(SSqlObj *pSql) {
  pSql->listed = 0;

  tscSaveSlowQuery(pSql);
-  tscDebug("%p removed from sqlList", pSql);
+  tscDebug("0x%"PRIx64" removed from sqlList", pSql->self);
 }

 void tscKillQuery(STscObj *pObj, uint32_t killId) {
@@ -158,7 +158,7 @@ void tscKillQuery(STscObj *pObj, uint32_t killId) {
  if (pSql == NULL) {
    tscError("failed to kill query, id:%d, it may have completed/terminated", killId);
  } else {
-    tscDebug("%p query is killed, queryId:%d", pSql, killId);
+    tscDebug("0x%"PRIx64" query is killed, queryId:%d", pSql->self, killId);
    taos_stop_query(pSql);
  }
 }
@@ -213,7 +213,7 @@ void tscKillStream(STscObj *pObj, uint32_t killId) {
  pthread_mutex_unlock(&pObj->mutex);

  if (pStream) {
-    tscDebug("%p stream:%p is killed, streamId:%d", pStream->pSql, pStream, killId);
+    tscDebug("0x%"PRIx64" stream:%p is killed, streamId:%d", pStream->pSql->self, pStream, killId);
    if (pStream->callback) {
      pStream->callback(pStream->param);
    }
@@ -249,8 +249,8 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
    pQdesc->stime = htobe64(pSql->stime);
    pQdesc->queryId = htonl(pSql->queryId);
    //pQdesc->useconds = htobe64(pSql->res.useconds);
-    pQdesc->useconds = htobe64(now - pSql->stime);  // use local time instead of sever rsp elapsed time
-    pQdesc->qHandle = htobe64(pSql->res.qId);
+    pQdesc->useconds = htobe64(now - pSql->stime);
+    pQdesc->qId = htobe64(pSql->res.qId);

    pHeartbeat->numOfQueries++;
    pQdesc++;
@@ -273,7 +273,7 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
    pSdesc->num = htobe64(pStream->num);

    pSdesc->useconds = htobe64(pStream->useconds);
-    pSdesc->stime = htobe64(pStream->stime - pStream->interval.interval);
+    pSdesc->stime = (pStream->stime == INT64_MIN) ? htobe64(pStream->stime) : htobe64(pStream->stime - pStream->interval.interval);
    pSdesc->ctime = htobe64(pStream->ctime);

    pSdesc->slidingTime = htobe64(pStream->interval.sliding);

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -191,7 +191,7 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
    pSql->fp = syncConnCallback;
    pSql->param = pSql;

-    tscProcessSql(pSql);
+    tscBuildAndSendRequest(pSql, NULL);
    tsem_wait(&pSql->rspSem);

    if (pSql->res.code != TSDB_CODE_SUCCESS) {
@@ -265,7 +265,7 @@ TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port,
  if (taos) *taos = pObj;

  pSql->fetchFp = fp;
-  pSql->res.code = tscProcessSql(pSql);
+  pSql->res.code = tscBuildAndSendRequest(pSql, NULL);
  tscDebug("%p DB async connection is opening", taos);
  return pObj;
 }
@@ -292,7 +292,7 @@ void taos_close(TAOS *taos) {
        pHb->rpcRid = -1;
      }

-      tscDebug("%p HB is freed", pHb);
+      tscDebug("0x%"PRIx64" HB is freed", pHb->self);
      taosReleaseRef(tscObjRef, pHb->self);
 #ifdef __APPLE__
      // to satisfy later tsem_destroy in taos_free_result
@@ -373,7 +373,7 @@ int taos_num_fields(TAOS_RES *res) {
  if (pSql == NULL || pSql->signature != pSql) return 0;

  int32_t num = 0;
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  if (pQueryInfo == NULL) {
    return num;
  }
@@ -408,7 +408,7 @@ TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
  SSqlRes *pRes = &pSql->res;
  if (pSql == NULL || pSql->signature != pSql) return 0;

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  if (pQueryInfo == NULL) {
    return NULL;
  }
@@ -559,9 +559,9 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
    return true;
  }

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);

-  if ((pQueryInfo == NULL) || tscIsTwoStageSTableQuery(pCmd, pQueryInfo, 0)) {
+  if ((pQueryInfo == NULL) || pQueryInfo->globalMerge) {
    return true;
  }

@@ -576,9 +576,9 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
       cmd == TSDB_SQL_FETCH)) {
    pQueryInfo->type = TSDB_QUERY_TYPE_FREE_RESOURCE;
    pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
-    tscDebug("%p send msg to dnode to free qhandle ASAP before free sqlObj, command:%s", pSql, sqlCmd[pCmd->command]);
+    tscDebug("0x%"PRIx64" send msg to dnode to free qhandle ASAP before free sqlObj, command:%s", pSql->self, sqlCmd[pCmd->command]);

-    tscProcessSql(pSql);
+    tscBuildAndSendRequest(pSql, NULL);
    return false;
  }

@@ -594,7 +594,7 @@ void taos_free_result(TAOS_RES *res) {

  bool freeNow = tscKillQueryInDnode(pSql);
  if (freeNow) {
-    tscDebug("%p free sqlObj in cache", pSql);
+    tscDebug("0x%"PRIx64" free sqlObj in cache", pSql->self);
    taosReleaseRef(tscObjRef, pSql->self);
  }
 }
@@ -672,9 +672,9 @@ char *taos_get_client_info() { return version; }
 static void tscKillSTableQuery(SSqlObj *pSql) {
  SSqlCmd* pCmd = &pSql->cmd;

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);

-  if (!tscIsTwoStageSTableQuery(pCmd, pQueryInfo, 0)) {
+  if (!pQueryInfo->globalMerge) {
    return;
  }

@@ -708,7 +708,7 @@ static void tscKillSTableQuery(SSqlObj *pSql) {

  tscUnlockByThread(&pSql->squeryLock);

-  tscDebug("%p super table query cancelled", pSql);
+  tscDebug("0x%"PRIx64" super table query cancelled", pSql->self);
 }

 void taos_stop_query(TAOS_RES *res) {
@@ -717,15 +717,15 @@ void taos_stop_query(TAOS_RES *res) {
    return;
  }

-  tscDebug("%p start to cancel query", res);
+  tscDebug("0x%"PRIx64" start to cancel query", pSql->self);
  SSqlCmd *pCmd = &pSql->cmd;

  // set the error code for master pSqlObj firstly
  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);

-  if (tscIsTwoStageSTableQuery(pCmd, pQueryInfo, 0)) {
+  if (pQueryInfo->globalMerge) {
    assert(pSql->rpcRid <= 0);
    tscKillSTableQuery(pSql);
  } else {
@@ -744,7 +744,7 @@ void taos_stop_query(TAOS_RES *res) {
    }
  }

-  tscDebug("%p query is cancelled", res);
+  tscDebug("0x%"PRIx64" query is cancelled", pSql->self);
 }

 bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
@@ -753,7 +753,7 @@ bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
    return true;
  }

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  if (pQueryInfo == NULL) {
    return true;
  }
@@ -877,7 +877,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  pRes->numOfClauseTotal = 0;


-  tscDebug("%p Valid SQL: %s pObj:%p", pSql, sql, pObj);
+  tscDebug("0x%"PRIx64" Valid SQL: %s pObj:%p", pSql->self, sql, pObj);

  int32_t sqlLen = (int32_t)strlen(sql);
  if (sqlLen > tsMaxSQLStringLen) {
@@ -889,7 +889,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
  if (pSql->sqlstr == NULL) {
    tscError("%p failed to malloc sql string buffer", pSql);
-    tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(pSql), pObj);
+    tscDebug("0x%"PRIx64" Valid SQL result:%d, %s pObj:%p", pSql->self, pRes->code, taos_errstr(pSql), pObj);
    tfree(pSql);
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
  }
@@ -914,7 +914,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  }

  if (code != TSDB_CODE_SUCCESS) {
-    tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, code, taos_errstr(pSql), pObj);
+    tscDebug("0x%"PRIx64" Valid SQL result:%d, %s pObj:%p", pSql->self, code, taos_errstr(pSql), pObj);
  }

  taos_free_result(pSql);
@@ -933,7 +933,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
  int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
  char *str = (char *)tblNameList;

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
  if (pQueryInfo == NULL) {
    pSql->res.code = terrno;
    return terrno;
@@ -1027,7 +1027,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  pRes->numOfClauseTotal = 0;

  assert(pSql->fp == NULL);
-  tscDebug("%p tableNameList: %s pObj:%p", pSql, tableNameList, pObj);
+  tscDebug("0x%"PRIx64" tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);

  int32_t tblListLen = (int32_t)strlen(tableNameList);
  if (tblListLen > MAX_TABLE_NAME_LENGTH) {
@@ -1048,7 +1048,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {

  /*
   * set the qhandle to 0 before return in order to erase the qhandle value assigned in the previous successful query.
-   * If qhandle is NOT set 0, the function of taos_free_result() will send message to server by calling tscProcessSql()
+   * If qhandle is NOT set 0, the function of taos_free_result() will send message to server by calling tscBuildAndSendRequest()
   * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
   */
  pRes->qId = 0;
@@ -1061,7 +1061,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {

  tscDoQuery(pSql);

-  tscDebug("%p load multi table meta result:%d %s pObj:%p", pSql, pRes->code, taos_errstr(pSql), pObj);
+  tscDebug("0x%"PRIx64" load multi-table meta result:%d %s pObj:%p", pSql->self, pRes->code, taos_errstr(pSql), pObj);
  if ((code = pRes->code) != TSDB_CODE_SUCCESS) {
    tscFreeSqlObj(pSql);
  }

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -37,8 +37,8 @@ static int64_t getDelayValueAfterTimewindowClosed(SSqlStream* pStream, int64_t l

 static bool isProjectStream(SQueryInfo* pQueryInfo) {
  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
-    if (pExpr->functionId != TSDB_FUNC_PRJ) {
+    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+    if (pExpr->base.functionId != TSDB_FUNC_PRJ) {
      return false;
    }
  }
@@ -70,7 +70,7 @@ static void setRetryInfo(SSqlStream* pStream, int32_t code) {

  pSql->res.code = code;
  int64_t retryDelayTime = tscGetRetryDelayTime(pStream, pStream->interval.sliding, pStream->precision);
-  tscDebug("%p stream:%p, get table Meta failed, retry in %" PRId64 "ms", pSql, pStream, retryDelayTime);
+  tscDebug("0x%"PRIx64" stream:%p, get table Meta failed, retry in %" PRId64 "ms", pSql->self, pStream, retryDelayTime);
  tscSetRetryTimer(pStream, pSql, retryDelayTime);
 }

@@ -89,7 +89,7 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
    return;
  }

-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);

  code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -101,14 +101,23 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
    return;
  }

+  if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo) && (pTableMetaInfo->pVgroupTables == NULL) && (pTableMetaInfo->vgroupList == NULL || pTableMetaInfo->vgroupList->numOfVgroups <= 0)) {
+    tscDebug("%p empty vgroup list", pSql);
+    pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
+    code = TSDB_CODE_TSC_APP_ERROR;
+  }
+
  // failed to get table Meta or vgroup list, retry in 10sec.
  if (code == TSDB_CODE_SUCCESS) {
    tscTansformFuncForSTableQuery(pQueryInfo);
-    tscDebug("%p stream:%p, start stream query on:%s", pSql, pStream, tNameGetTableName(&pTableMetaInfo->name));
+    tscDebug("0x%"PRIx64" stream:%p, start stream query on:%s", pSql->self, pStream, tNameGetTableName(&pTableMetaInfo->name));
+
+    pQueryInfo->command = TSDB_SQL_SELECT;
+    pSql->cmd.active = pQueryInfo;

    pSql->fp = tscProcessStreamQueryCallback;
    pSql->fetchFp = tscProcessStreamQueryCallback;
-    tscDoQuery(pSql);
+    executeQuery(pSql, pQueryInfo);
    tscIncStreamExecutionCount(pStream);
  } else {
    setRetryInfo(pStream, code);
@@ -130,8 +139,8 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {

  pStream->numOfRes = 0;  // reset the numOfRes.
  SSqlObj *pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  tscDebug("%p add into timer", pSql);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  tscDebug("0x%"PRIx64" add into timer", pSql->self);

  if (pStream->isProject) {
    /*
@@ -208,7 +217,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
 static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) {
 #if 0
  SSqlObj *   pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  
  if (pQueryInfo->fillType != TSDB_FILL_SET_VALUE && pQueryInfo->fillType != TSDB_FILL_NULL) {
    return;
@@ -237,7 +246,7 @@ static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) {
  }

  if (rowNum > 0) {
-    tscDebug("%p stream:%p %d rows padded", pSql, pStream, rowNum);
+    tscDebug("0x%"PRIx64" stream:%p %d rows padded", pSql, pStream, rowNum);
  }

  pRes->numOfRows = 0;
@@ -263,7 +272,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
    for(int32_t i = 0; i < numOfRows; ++i) {
      TAOS_ROW row = taos_fetch_row(res);
      if (row != NULL) {
-        tscDebug("%p stream:%p fetch result", pSql, pStream);
+        tscDebug("0x%"PRIx64" stream:%p fetch result", pSql->self, pStream);
        tscStreamFillTimeGap(pStream, *(TSKEY*)row[0]);
        pStream->stime = *(TSKEY *)row[0];
        // user callback function
@@ -293,7 +302,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
      pStream->stime += 1;
    }

-    tscDebug("%p stream:%p, query on:%s, fetch result completed, fetched rows:%" PRId64, pSql, pStream, tNameGetTableName(&pTableMetaInfo->name),
+    tscDebug("0x%"PRIx64" stream:%p, query on:%s, fetch result completed, fetched rows:%" PRId64, pSql->self, pStream, tNameGetTableName(&pTableMetaInfo->name),
             pStream->numOfRes);

    tfree(pTableMetaInfo->pTableMeta);
@@ -318,8 +327,8 @@ static void tscSetRetryTimer(SSqlStream *pStream, SSqlObj *pSql, int64_t timer)
      /*
       * current time window will be closed, since it too early to exceed the maxRetentWindow value
       */
-      tscDebug("%p stream:%p, etime:%" PRId64 " is too old, exceeds the max retention time window:%" PRId64 ", stop the stream",
-               pStream->pSql, pStream, pStream->stime, pStream->etime);
+      tscDebug("0x%"PRIx64" stream:%p, etime:%" PRId64 " is too old, exceeds the max retention time window:%" PRId64 ", stop the stream",
+               pStream->pSql->self, pStream, pStream->stime, pStream->etime);
      // TODO : How to terminate stream here
      if (pStream->callback) {
        // Callback function from upper level
@@ -329,10 +338,10 @@ static void tscSetRetryTimer(SSqlStream *pStream, SSqlObj *pSql, int64_t timer)
      return;
    }
  
-    tscDebug("%p stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql, pStream,
+    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
             now + timer, timer, delay, pStream->stime, etime);
  } else {
-    tscDebug("%p stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql, pStream,
+    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
             pStream->stime, timer, delay, pStream->stime - pStream->interval.interval, pStream->stime - 1);
  }

@@ -378,8 +387,8 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
     */
    timer = pStream->interval.sliding;
    if (pStream->stime > pStream->etime) {
-      tscDebug("%p stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream", pStream->pSql, pStream,
-               pStream->stime, pStream->etime);
+      tscDebug("0x%"PRIx64" stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream",
+          pStream->pSql->self, pStream, pStream->stime, pStream->etime);
      // TODO : How to terminate stream here
      if (pStream->callback) {
        // Callback function from upper level
@@ -392,7 +401,7 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
    int64_t stime = taosTimeTruncate(pStream->stime - 1, &pStream->interval, pStream->precision);
    //int64_t stime = taosGetIntervalStartTimestamp(pStream->stime - 1, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
    if (stime >= pStream->etime) {
-      tscDebug("%p stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream", pStream->pSql, pStream,
+      tscDebug("0x%"PRIx64" stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream", pStream->pSql->self, pStream,
               pStream->stime, pStream->etime);
      // TODO : How to terminate stream here
      if (pStream->callback) {
@@ -403,11 +412,13 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
      return;
    }

+    if (pStream->stime > 0) {
      timer = pStream->stime - taosGetTimestamp(pStream->precision);
      if (timer < 0) {
        timer = 0;
      }
    }
+  }

  timer += getLaunchTimeDelay(pStream);
  
@@ -422,7 +433,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
  int64_t minIntervalTime =
      (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsMinIntervalTime * 1000L : tsMinIntervalTime;
  
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);

  if (!pStream->isProject && pQueryInfo->interval.interval == 0) {
    sprintf(pSql->cmd.payload, "the interval value is 0");
@@ -472,24 +483,27 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
 }

 static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, int64_t stime) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
  
  if (pStream->isProject) {
    // no data in table, flush all data till now to destination meter, 10sec delay
    pStream->interval.interval = tsProjectExecInterval;
    pStream->interval.sliding = tsProjectExecInterval;

-    if (stime != 0) {  // first projection start from the latest event timestamp
+    if (stime != INT64_MIN) {  // first projection start from the latest event timestamp
      assert(stime >= pQueryInfo->window.skey);
      stime += 1;  // exclude the last records from table
    } else {
      stime = pQueryInfo->window.skey;
    }
  } else {             // timewindow based aggregation stream
-    if (stime == 0) {  // no data in meter till now
+    if (stime == INT64_MIN) {  // no data in meter till now
      if (pQueryInfo->window.skey != INT64_MIN) {
        stime = pQueryInfo->window.skey;
+      } else {
+        return stime;
      }
+
      stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
    } else {
      int64_t newStime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
@@ -531,7 +545,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
    return;
  }

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
  
@@ -558,7 +572,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {

  taosTmrReset(tscProcessStreamTimer, (int32_t)starttime, pStream, tscTmr, &pStream->pTimer);

-  tscDebug("%p stream:%p is opened, query on:%s, interval:%" PRId64 ", sliding:%" PRId64 ", first launched in:%" PRId64 ", sql:%s", pSql,
+  tscDebug("0x%"PRIx64" stream:%p is opened, query on:%s, interval:%" PRId64 ", sliding:%" PRId64 ", first launched in:%" PRId64 ", sql:%s", pSql->self,
           pStream, tNameGetTableName(&pTableMetaInfo->name), pStream->interval.interval, pStream->interval.sliding, starttime, pSql->sqlstr);
 }

@@ -619,7 +633,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
  if (code == TSDB_CODE_SUCCESS) {
    tscCreateStream(pStream, pSql, code);
  } else if (code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-    tscError("%p open stream failed, sql:%s, code:%s", pSql, sqlstr, tstrerror(pRes->code));
+    tscError("%p open stream failed, sql:%s, code:%s", pSql, sqlstr, tstrerror(code));
    taosReleaseRef(tscObjRef, pSql->self);
    free(pStream);
    return NULL;
@@ -645,7 +659,7 @@ void taos_close_stream(TAOS_STREAM *handle) {

    taosTmrStopA(&(pStream->pTimer));

-    tscDebug("%p stream:%p is closed", pSql, pStream);
+    tscDebug("0x%"PRIx64" stream:%p is closed", pSql->self, pStream);
    // notify CQ to release the pStream object
    pStream->fp(pStream->param, NULL, NULL);
    pStream->pSql = NULL;

--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -284,7 +284,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
  }
  size_t numOfTables = taosArrayGetSize(tables);

-  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
  SArray* progress = taosArrayInit(numOfTables, sizeof(SSubscriptionProgress));
  for( size_t i = 0; i < numOfTables; i++ ) {
    STidTags* tt = taosArrayGet( tables, i );
@@ -304,7 +304,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
  }
  taosArrayDestroy(tables);

-  TSDB_QUERY_SET_TYPE(tscGetQueryInfoDetail(pCmd, 0)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
+  TSDB_QUERY_SET_TYPE(tscGetQueryInfo(pCmd, 0)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
  return 1;
 }

@@ -487,11 +487,13 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
    if (pSql == NULL) {
      return NULL;
    }
+
    if (pSub->pSql->self != 0) {
      taosReleaseRef(tscObjRef, pSub->pSql->self);
    } else {
      tscFreeSqlObj(pSub->pSql);
    }
+
    pSub->pSql = pSql;
    pSql->pSubscription = pSub;
  }
@@ -502,7 +504,7 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
  SSqlRes *pRes = &pSql->res;
  SSqlCmd *pCmd = &pSql->cmd;
  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
  if (taosArrayGetSize(pSub->progress) > 0) { // fix crash in single table subscription

    size_t size = taosArrayGetSize(pSub->progress);
@@ -555,7 +557,10 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
    pSql->fp = asyncCallback;
    pSql->fetchFp = asyncCallback;
    pSql->param = pSub;
-    tscDoQuery(pSql);
+
+    pSql->cmd.active = pQueryInfo;
+    executeQuery(pSql, pQueryInfo);
+
    tsem_wait(&pSub->sem);

    if (pRes->code != TSDB_CODE_SUCCESS) {

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
--- a/src/common/inc/texpr.h
+++ b/src/common/inc/texpr.h
@@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef TDENGINE_TAST_H
-#define TDENGINE_TAST_H
+#ifndef TDENGINE_TEXPR_H
+#define TDENGINE_TEXPR_H

 #ifdef __cplusplus
 extern "C" {
@@ -64,30 +64,30 @@ typedef struct tExprNode {
    struct {
      uint8_t           optr;   // filter operator
      uint8_t           hasPK;  // 0: do not contain primary filter, 1: contain
-      void *  info;             // support filter operation on this expression only available for leaf node
-
+      void             *info;   // support filter operation on this expression only available for leaf node
      struct tExprNode *pLeft;  // left child pointer
      struct tExprNode *pRight; // right child pointer
    } _node;
+
    struct SSchema     *pSchema;
-    tVariant *      pVal;
+    tVariant           *pVal;
  };
 } tExprNode;

 typedef struct SExprTraverseSupp {
  __result_filter_fn_t   nodeFilterFn;
  __do_filter_suppl_fn_t setupInfoFn;
-  void *                 pExtInfo;
+  void                  *pExtInfo;
 } SExprTraverseSupp;

 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *));

+void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
 tExprNode* exprTreeFromBinary(const void* data, size_t size);
 tExprNode* exprTreeFromTableName(const char* tbnameCond);
+tExprNode* exprdup(tExprNode* pTree);

-void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
-
-bool exprTreeApplayFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param);
+bool exprTreeApplyFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param);

 typedef void (*_arithmetic_operator_fn_t)(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight,
                                          int32_t rightType, void *output, int32_t order);
@@ -99,4 +99,4 @@ void arithmeticTreeTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput,
 }
 #endif

-#endif  // TDENGINE_TAST_H
+#endif  // TDENGINE_TEXPR_H
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -41,6 +41,35 @@ typedef struct SResPair {
  double avg;
 } SResPair;

+// the structure for sql function in select clause
+typedef struct SSqlExpr {
+  char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
+  SColIndex colInfo;
+
+  uint64_t  uid;            // refactor use the pointer
+
+  int16_t   functionId;     // function id in aAgg array
+
+  int16_t   resType;        // return value type
+  int16_t   resBytes;       // length of return value
+  int32_t   interBytes;     // inter result buffer size
+
+  int16_t   colType;        // table column type
+  int16_t   colBytes;       // table column bytes
+
+  int16_t   numOfParams;    // argument value of each function
+  tVariant  param[3];       // parameters are not more than 3
+  int32_t   offset;         // sub result column value of arithmetic expression.
+  int16_t   resColId;       // result column id
+
+  SColumnFilterList flist;
+} SSqlExpr;
+
+typedef struct SExprInfo {
+  SSqlExpr           base;
+  struct tExprNode  *pExpr;
+} SExprInfo;
+
 #define TSDB_DB_NAME_T     1
 #define TSDB_TABLE_NAME_T  2


--- a/src/common/src/texpr.c
+++ b/src/common/src/texpr.c
@@ -15,6 +15,7 @@

 #include "os.h"

+#include "texpr.h"
 #include "exception.h"
 #include "taosdef.h"
 #include "taosmsg.h"
@@ -145,25 +146,25 @@ static void doExprTreeDestroy(tExprNode **pExpr, void (*fp)(void *)) {
  *pExpr = NULL;
 }

-bool exprTreeApplayFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param) {
+bool exprTreeApplyFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param) {
  tExprNode *pLeft  = pExpr->_node.pLeft;
  tExprNode *pRight = pExpr->_node.pRight;

  //non-leaf nodes, recursively traverse the expression tree in the post-root order
  if (pLeft->nodeType == TSQL_NODE_EXPR && pRight->nodeType == TSQL_NODE_EXPR) {
    if (pExpr->_node.optr == TSDB_RELATION_OR) {  // or
-      if (exprTreeApplayFilter(pLeft, pItem, param)) {
+      if (exprTreeApplyFilter(pLeft, pItem, param)) {
        return true;
      }

      // left child does not satisfy the query condition, try right child
-      return exprTreeApplayFilter(pRight, pItem, param);
+      return exprTreeApplyFilter(pRight, pItem, param);
    } else {  // and
-      if (!exprTreeApplayFilter(pLeft, pItem, param)) {
+      if (!exprTreeApplyFilter(pLeft, pItem, param)) {
        return false;
      }

-      return exprTreeApplayFilter(pRight, pItem, param);
+      return exprTreeApplyFilter(pRight, pItem, param);
    }
  }

@@ -463,3 +464,28 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
  CLEANUP_EXECUTE_TO(anchor, false);
  return expr;
 }
+
+tExprNode* exprdup(tExprNode* pTree) {
+  if (pTree == NULL) {
+    return NULL;
+  }
+
+  tExprNode* pNode = calloc(1, sizeof(tExprNode));
+  if (pTree->nodeType == TSQL_NODE_EXPR) {
+    tExprNode* pLeft  = exprdup(pTree->_node.pLeft);
+    tExprNode* pRight = exprdup(pTree->_node.pRight);
+
+    pNode->nodeType     = TSQL_NODE_EXPR;
+    pNode->_node.pLeft  = pLeft;
+    pNode->_node.pRight = pRight;
+  } else if (pTree->nodeType == TSQL_NODE_VALUE) {
+    pNode->pVal = calloc(1, sizeof(tVariant));
+    tVariantAssign(pNode->pVal, pTree->pVal);
+  } else if (pTree->nodeType == TSQL_NODE_COL) {
+    pNode->pSchema = calloc(1, sizeof(SSchema));
+    *pNode->pSchema = *pTree->pSchema;
+  }
+
+  return pNode;
+}
+
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -68,6 +68,7 @@ bool tscValidateTableNameLength(size_t len) {
  return len < TSDB_TABLE_NAME_LEN;
 }

+// TODO refactor
 SColumnFilterInfo* tFilterInfoDup(const SColumnFilterInfo* src, int32_t numOfFilters) {
  if (numOfFilters == 0) {
    assert(src == NULL);

--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -48,10 +48,21 @@ void tVariantCreate(tVariant *pVar, SStrToken *token) {
    case TSDB_DATA_TYPE_INT:{
      ret = tStrToInteger(token->z, token->type, token->n, &pVar->i64, true);
      if (ret != 0) {
+        SStrToken t = {0};
+        tSQLGetToken(token->z, &t.type);
+        if (t.type == TK_MINUS) {  // it is a signed number which is greater than INT64_MAX or less than INT64_MIN
          pVar->nType = -1;   // -1 means error type
          return;
        }

+        // data overflow, try unsigned parse the input number
+        ret = tStrToInteger(token->z, token->type, token->n, &pVar->i64, false);
+        if (ret != 0) {
+          pVar->nType = -1;   // -1 means error type
+          return;
+        }
+      }
+
      break;
    }

@@ -525,6 +536,8 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
  }

  bool code = false;
+
+  uint64_t ui = 0;
  switch(type) {
    case TSDB_DATA_TYPE_TINYINT:
      code = IS_VALID_TINYINT(*result); break;
@@ -535,13 +548,17 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
    case TSDB_DATA_TYPE_BIGINT:
      code = IS_VALID_BIGINT(*result); break;
    case TSDB_DATA_TYPE_UTINYINT:
-      code = IS_VALID_UTINYINT(*result); break;
+      ui = *result;
+      code = IS_VALID_UTINYINT(ui); break;
    case TSDB_DATA_TYPE_USMALLINT:
-      code = IS_VALID_USMALLINT(*result); break;
+      ui = *result;
+      code = IS_VALID_USMALLINT(ui); break;
    case TSDB_DATA_TYPE_UINT:
-      code = IS_VALID_UINT(*result); break;
+      ui = *result;
+      code = IS_VALID_UINT(ui); break;
    case TSDB_DATA_TYPE_UBIGINT:
-      code = IS_VALID_UBIGINT(*result); break;
+      ui = *result;
+      code = IS_VALID_UBIGINT(ui); break;
  }

  return code? 0:-1;

--- a/src/connector/C#/TDengineDriver.cs
+++ b/src/connector/C#/TDengineDriver.cs
@@ -31,7 +31,11 @@ namespace TDengineDriver
        TSDB_DATA_TYPE_DOUBLE = 7,   // 8 bytes
        TSDB_DATA_TYPE_BINARY = 8,   // string
        TSDB_DATA_TYPE_TIMESTAMP = 9,// 8 bytes
-        TSDB_DATA_TYPE_NCHAR = 10    // unicode string
+        TSDB_DATA_TYPE_NCHAR = 10,   // unicode string
+        TSDB_DATA_TYPE_UTINYINT = 11,// 1 byte
+        TSDB_DATA_TYPE_USMALLINT= 12,// 2 bytes
+        TSDB_DATA_TYPE_UINT = 13,    // 4 bytes
+        TSDB_DATA_TYPE_UBIGINT= 14   // 8 bytes
    }

    enum TDengineInitOption
@@ -53,15 +57,23 @@ namespace TDengineDriver
            switch ((TDengineDataType)type)
            {
                case TDengineDataType.TSDB_DATA_TYPE_BOOL:
-                    return "BOOLEAN";
+                    return "BOOL";
                case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
-                    return "BYTE";
+                    return "TINYINT";
                case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
-                    return "SHORT";
+                    return "SMALLINT";
                case TDengineDataType.TSDB_DATA_TYPE_INT:
                    return "INT";
                case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
-                    return "LONG";
+                    return "BIGINT";
+                case TDengineDataType.TSDB_DATA_TYPE_UTINYINT:
+                    return "TINYINT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_USMALLINT:
+                    return "SMALLINT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_UINT:
+                    return "INT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_UBIGINT:
+                    return "BIGINT UNSIGNED";
                case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
                    return "FLOAT";
                case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:

--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
  ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
    POST_BUILD
    COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.27-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.28-dist.jar ${LIBRARY_OUTPUT_PATH}
    COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
    COMMENT "build jdbc driver")
  ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})

--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@@ -5,7 +5,7 @@

  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.27</version>
+  <version>2.0.28</version>
  <packaging>jar</packaging>

  <name>JDBCDriver</name>

--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -3,7 +3,7 @@
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.taosdata.jdbc</groupId>
    <artifactId>taos-jdbcdriver</artifactId>
-    <version>2.0.27</version>
+    <version>2.0.28</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractResultSet.java
@@ -10,6 +10,7 @@ import java.util.Map;

 public abstract class AbstractResultSet extends WrapperImpl implements ResultSet {
    private int fetchSize;
+    protected boolean wasNull;

    protected void checkAvailability(int columnIndex, int bounds) throws SQLException {
        if (isClosed())
@@ -28,7 +29,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet

    @Override
    public boolean wasNull() throws SQLException {
-        return false;
+        return wasNull;
    }

    @Override

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
@@ -6,12 +6,10 @@ import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
 import com.taosdata.jdbc.*;
-import com.taosdata.jdbc.utils.UtcTimestampUtil;

 import java.math.BigDecimal;
 import java.sql.*;
 import java.time.Instant;
-import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.util.ArrayList;
 import java.util.Calendar;
@@ -89,7 +87,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
                String timestampFormat = this.statement.getConnection().getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT);
                if ("TIMESTAMP".equalsIgnoreCase(timestampFormat)) {
                    Long value = row.getLong(colIndex);
-                    //TODO:
+                    //TODO: this implementation has bug if the timestamp bigger than 9999_9999_9999_9
                    if (value < 1_0000_0000_0000_0L)
                        return new Timestamp(value);
                    long epochSec = value / 1000_000l;
@@ -164,12 +162,12 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        }
    }

-    @Override
-    public boolean wasNull() throws SQLException {
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        return resultSet.isEmpty();
-    }
+//    @Override
+//    public boolean wasNull() throws SQLException {
+//        if (isClosed())
+//            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
+//        return resultSet.isEmpty();
+//    }

    @Override
    public String getString(int columnIndex) throws SQLException {
@@ -188,8 +186,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return false;
+        }
+        wasNull = false;
        if (value instanceof Boolean)
            return (boolean) value;
        return Boolean.valueOf(value.toString());
@@ -200,8 +201,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        long valueAsLong = Long.parseLong(value.toString());
        if (valueAsLong == Byte.MIN_VALUE)
            return 0;
@@ -221,8 +225,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        long valueAsLong = Long.parseLong(value.toString());
        if (valueAsLong == Short.MIN_VALUE)
            return 0;
@@ -236,8 +243,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        long valueAsLong = Long.parseLong(value.toString());
        if (valueAsLong == Integer.MIN_VALUE)
            return 0;
@@ -251,12 +261,14 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        if (value instanceof Timestamp) {
            return ((Timestamp) value).getTime();
        }
-
        long valueAsLong = 0;
        try {
            valueAsLong = Long.parseLong(value.toString());
@@ -273,8 +285,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        if (value instanceof Float || value instanceof Double)
            return (float) value;
        return Float.parseFloat(value.toString());
@@ -285,8 +300,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        checkAvailability(columnIndex, resultSet.get(pos).size());

        Object value = resultSet.get(pos).get(columnIndex - 1);
-        if (value == null)
+        if (value == null) {
+            wasNull = true;
            return 0;
+        }
+        wasNull = false;
        if (value instanceof Double || value instanceof Float)
            return (double) value;
        return Double.parseDouble(value.toString());

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TD3841Test.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TD3841Test.java
--- a/src/connector/python/linux/python2/setup.py
+++ b/src/connector/python/linux/python2/setup.py
@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:

 setuptools.setup(
    name="taos",
-    version="2.0.7",
+    version="2.0.8",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",

--- a/src/connector/python/linux/python2/taos/cursor.py
+++ b/src/connector/python/linux/python2/taos/cursor.py
@@ -42,7 +42,7 @@ class TDengineCursor(object):
    def __iter__(self):
        return self

-    def __next__(self):
+    def next(self):
        if self._result is None or self._fields is None:
            raise OperationalError("Invalid use of fetch iterator")


--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -311,7 +311,22 @@ void *cqCreate(void *handle, uint64_t uid, int32_t sid, const char* dstTable, ch
  SCqContext *pContext = handle;
  int64_t rid = 0;

-  SCqObj *pObj = calloc(sizeof(SCqObj), 1);
+  pthread_mutex_lock(&pContext->mutex);
+
+  SCqObj *pObj = pContext->pHead;
+  while (pObj) {
+    if (pObj->uid == uid) {
+      rid = pObj->rid;
+      pthread_mutex_unlock(&pContext->mutex);
+      return (void *)rid;
+    }
+    
+    pObj = pObj->next;
+  }
+  
+  pthread_mutex_unlock(&pContext->mutex);
+  
+  pObj = calloc(sizeof(SCqObj), 1);
  if (pObj == NULL) return NULL;

  pObj->uid = uid;
@@ -389,9 +404,12 @@ static void doCreateStream(void *param, TAOS_RES *result, int32_t code) {

  SCqContext* pContext = pObj->pContext;
  SSqlObj* pSql = (SSqlObj*)result;  
+  if (code == TSDB_CODE_SUCCESS) {
    if (atomic_val_compare_exchange_ptr(&(pContext->dbConn), NULL, pSql->pTscObj) != NULL) {
      taos_close(pSql->pTscObj);
    }
+  }
+  
  pthread_mutex_lock(&pContext->mutex);
  cqCreateStream(pContext, pObj);
  pthread_mutex_unlock(&pContext->mutex);
@@ -427,10 +445,11 @@ static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
    pObj->tmrId = taosTmrStart(cqProcessCreateTimer, 1000, (void *)pObj->rid, pContext->tmrCtrl);
    return;
  }
+
  pObj->tmrId = 0;

  if (pObj->pStream == NULL) {
-    pObj->pStream = taos_open_stream(pContext->dbConn, pObj->sqlStr, cqProcessStreamRes, 0, (void *)pObj->rid, NULL);
+    pObj->pStream = taos_open_stream(pContext->dbConn, pObj->sqlStr, cqProcessStreamRes, INT64_MIN, (void *)pObj->rid, NULL);

    // TODO the pObj->pStream may be released if error happens
    if (pObj->pStream) {

--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/mnode/src/mnodeProfile.c
+++ b/src/mnode/src/mnodeProfile.c
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
--- a/src/os/inc/osMips64.h
+++ b/src/os/inc/osMips64.h
--- a/src/os/src/darwin/darwinSysInfo.c
+++ b/src/os/src/darwin/darwinSysInfo.c
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
--- a/src/os/tests/test.cpp
+++ b/src/os/tests/test.cpp
--- a/src/plugins/http/inc/httpContext.h
+++ b/src/plugins/http/inc/httpContext.h
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
--- a/src/plugins/http/src/httpHandle.c
+++ b/src/plugins/http/src/httpHandle.c
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
--- a/src/query/inc/qAggMain.h
+++ b/src/query/inc/qAggMain.h
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
--- a/src/query/inc/qExtbuffer.h
+++ b/src/query/inc/qExtbuffer.h
--- a/src/query/inc/qPlan.h
+++ b/src/query/inc/qPlan.h
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
--- a/src/query/src/qResultbuf.c
+++ b/src/query/src/qResultbuf.c
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/src/queryMain.c
+++ b/src/query/src/queryMain.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
--- a/src/util/src/tcrc32c.c
+++ b/src/util/src/tcrc32c.c
--- a/src/util/src/tlog.c
+++ b/src/util/src/tlog.c
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
--- a/src/util/src/ttimer.c
+++ b/src/util/src/ttimer.c
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
--- a/tests/examples/C#/C#checker/C#checker.cs
+++ b/tests/examples/C#/C#checker/C#checker.cs
--- a/tests/examples/C#/TDengineDriver.cs
+++ b/tests/examples/C#/TDengineDriver.cs
--- a/tests/examples/C#/TDengineTest.cs
+++ b/tests/examples/C#/TDengineTest.cs
--- a/tests/examples/C#/taosdemo/taosdemo.cs
+++ b/tests/examples/C#/taosdemo/taosdemo.cs
--- a/tests/examples/JDBC/springbootdemo/pom.xml
+++ b/tests/examples/JDBC/springbootdemo/pom.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
--- a/tests/examples/go/taosdemo.go
+++ b/tests/examples/go/taosdemo.go
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
--- a/tests/pytest/alter/alterTabAddTagWithNULL.py
+++ b/tests/pytest/alter/alterTabAddTagWithNULL.py
--- a/tests/pytest/alter/alterTimestampColDataProcess.py
+++ b/tests/pytest/alter/alterTimestampColDataProcess.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/query/queryFilterTswithDateUnit.py
+++ b/tests/pytest/query/queryFilterTswithDateUnit.py
--- a/tests/pytest/query/queryNormal.py
+++ b/tests/pytest/query/queryNormal.py
--- a/tests/pytest/query/querySecondtscolumnTowherenow.py
+++ b/tests/pytest/query/querySecondtscolumnTowherenow.py
--- a/tests/pytest/stream/new.py
+++ b/tests/pytest/stream/new.py
--- a/tests/pytest/stream/stream2.py
+++ b/tests/pytest/stream/stream2.py
--- a/tests/pytest/stream/sys.py
+++ b/tests/pytest/stream/sys.py
--- a/tests/pytest/tools/taosdemoTestTblAlt.py
+++ b/tests/pytest/tools/taosdemoTestTblAlt.py
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
--- a/tests/script/general/parser/alter1.sim
+++ b/tests/script/general/parser/alter1.sim
--- a/tests/script/general/parser/col_arithmetic_query.sim
+++ b/tests/script/general/parser/col_arithmetic_query.sim
--- a/tests/script/general/parser/first_last_query.sim
+++ b/tests/script/general/parser/first_last_query.sim
--- a/tests/script/general/parser/having.sim
+++ b/tests/script/general/parser/having.sim
--- a/tests/script/general/parser/having_child.sim
+++ b/tests/script/general/parser/having_child.sim
--- a/tests/script/general/parser/join_multivnode.sim
+++ b/tests/script/general/parser/join_multivnode.sim
--- a/tests/script/general/parser/limit2_query.sim
+++ b/tests/script/general/parser/limit2_query.sim
--- a/tests/script/general/parser/select_with_tags.sim
+++ b/tests/script/general/parser/select_with_tags.sim
--- a/tests/script/general/parser/subInfrom.sim
+++ b/tests/script/general/parser/subInfrom.sim
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
--- a/tests/script/general/stream/stream_1970.sim
+++ b/tests/script/general/stream/stream_1970.sim
--- a/tests/script/test.sh
+++ b/tests/script/test.sh
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c