[td-225]merge develop

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)

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

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不是线程安全的。
 

documentation20/cn/08.connector/docs.md

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

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个数。

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>数据库管理
 

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

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
 }

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);
+bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
-SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
+SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
-SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
 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);
+void        tscInitQueryInfo(SQueryInfo* pQueryInfo);
-SQueryInfo *tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex);
+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);

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,12 +97,22 @@ typedef struct STableMetaInfo {
   SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
 } STableMetaInfo;
 
-
 typedef struct SColumnIndex {
   int16_t tableIndex;
   int16_t columnIndex;
 } SColumnIndex;
 
+typedef struct SColumn {
+  uint64_t     tableUid;
+  int32_t      columnIndex;
+  SColumnInfo  info;
+} SColumn;
+
+typedef struct SInternalField {
+  TAOS_FIELD      field;
+  bool            visible;
+  SExprInfo      *pExpr;
+} SInternalField;
 
 typedef struct SFieldInfo {
   int16_t      numOfOutput;   // number of column in result
@@ -109,43 +120,6 @@ typedef struct SFieldInfo {
   SArray      *internalField; // SArray<SInternalField>
 } SFieldInfo;
 
-typedef struct SColumn {
-  SColumnIndex       colIndex;
-  int32_t            numOfFilters;
-  SColumnFilterInfo *filterInfo;
-} 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;
-} SInternalField;
-
 typedef struct SCond {
   uint64_t uid;
   int32_t  len;  // length of tag query condition data
@@ -160,7 +134,7 @@ typedef struct SJoinNode {
 } SJoinNode;
 
 typedef struct SJoinInfo {
-  bool      hasJoin;  
+  bool      hasJoin;
   SJoinNode*  joinTables[TSDB_MAX_JOIN_TABLE_NUM];
 } SJoinInfo;
 
@@ -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;
-  int32_t          havingFieldNum;
+  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 {
@@ -263,15 +248,13 @@ typedef struct {
   char    reserve1[3];        // fix bus error on arm32
   bool    autoCreated;        // create table if it is not existed during retrieve table meta in mnode
   bool    subCmd;
-  
+
   union {
     int32_t count;
     int32_t numOfTablesInSubmit;
   };
 
   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,22 +264,26 @@ 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;
 
   int8_t       dataSourceType;     // load data from file or not
-  char         reserve4[3];        // fix bus error on arm32
+  char    reserve4[3];         // fix bus error on arm32
   int8_t       submitSchema;   // submit block is built with table schema
-  char         reserve5[3];        // fix bus error on arm32
+  char    reserve5[3];         // fix bus error on arm32
   STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
 
   SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
   int32_t      numOfTables;
 
   SHashObj    *pTableBlockHashList;     // data block for each table
-  SArray      *pDataBlocks;    // SArray<STableDataBlocks*>. Merged submit block for each vgroup
+  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
   SArray      *pUdfInfo;       // user defined function information SArray<SUdfInfo>
 } SSqlCmd;
 
@@ -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;

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

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

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) {
+void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
-  SSqlObj *pSql = (SSqlObj *)taosa;
+  SSqlObj *pSql = (SSqlObj *)tres;
   if (pSql == NULL || pSql->signature != pSql) {
     tscError("sql object is NULL");
     tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED);
@@ -206,18 +207,16 @@ 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->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
@@ -255,8 +254,9 @@ void taos_fetch_rows_a(TAOS_RES *taosa, __async_cb_func_t fp, void *param) {
     if (pCmd->command != TSDB_SQL_RETRIEVE_LOCALMERGE && pCmd->command < TSDB_SQL_LOCAL) {
       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
+      // tscBuildAndSendRequest can add error into async res
-      tscProcessSql(pSql);
+      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,21 +447,29 @@ 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);
             return;
           } else {
-            assert(code == TSDB_CODE_SUCCESS);      
+            assert(code == TSDB_CODE_SUCCESS);
           }
 
           (*pSql->fp)(pSql->param, pSql, code);
-          taosReleaseRef(tscObjRef, pSql->self);
+        } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
-          return;
+          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);
   

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

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

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

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->useconds = htobe64(now - pSql->stime);
-    pQdesc->qHandle = htobe64(pSql->res.qId);
+    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);

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

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);
+    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-    if (pExpr->functionId != TSDB_FUNC_PRJ) {
+    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);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
-  tscDebug("%p add into timer", pSql);
+  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",
+      tscDebug("0x%"PRIx64" stream:%p, etime:%" PRId64 " is too old, exceeds the max retention time window:%" PRId64 ", stop the stream",
-               pStream->pSql, pStream, pStream->stime, pStream->etime);
+               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,
+      tscDebug("0x%"PRIx64" stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream",
-               pStream->stime, pStream->etime);
+          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) {
@@ -402,10 +411,12 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
       taos_close_stream(pStream);
       return;
     }
-    
+
-    timer = pStream->stime - taosGetTimestamp(pStream->precision);
+    if (pStream->stime > 0) {
-    if (timer < 0) {
+      timer = pStream->stime - taosGetTimestamp(pStream->precision);
-      timer = 0;
+      if (timer < 0) {
+        timer = 0;
+      }
     }
   }
 
@@ -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;

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

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
+#ifndef TDENGINE_TEXPR_H
-#define TDENGINE_TAST_H
+#define TDENGINE_TEXPR_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -62,32 +62,32 @@ typedef struct tExprNode {
   uint8_t nodeType;
   union {
     struct {
-      uint8_t optr;             // filter operator
+      uint8_t           optr;   // filter operator
-      uint8_t hasPK;            // 0: do not contain primary filter, 1: contain
+      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;
+    struct SSchema     *pSchema;
+    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 exprTreeApplyFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param);
-
-bool exprTreeApplayFilter(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

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
 

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;
+}
+

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

src/common/src/tvariant.c

@@ -48,8 +48,19 @@ 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) {
-        pVar->nType = -1;   // -1 means error type
+        SStrToken t = {0};
-        return;
+        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;

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:

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

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>

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>

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

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
+//    @Override
-    public boolean wasNull() throws SQLException {
+//    public boolean wasNull() throws SQLException {
-        if (isClosed())
+//        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
+//            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        return resultSet.isEmpty();
+//        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());

src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TD3841Test.java

@@ -0,0 +1,91 @@
+package com.taosdata.jdbc.cases;
+
+import com.taosdata.jdbc.TSDBDriver;
+import com.taosdata.jdbc.utils.TimestampUtil;
+import org.junit.*;
+
+import java.sql.*;
+import java.util.Properties;
+
+public class TD3841Test {
+    private static final String host = "127.0.0.1";
+    private static Properties properties;
+    private static Connection conn_restful;
+    private static Connection conn_jni;
+
+    @Test
+    public void testRestful() throws SQLException {
+        String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
+        conn_restful = DriverManager.getConnection(url, properties);
+
+        try (Statement stmt = conn_restful.createStatement()) {
+            stmt.execute("drop database if exists test_null");
+            stmt.execute("create database if not exists test_null");
+            stmt.execute("use test_null");
+            stmt.execute("create table weather(ts timestamp, f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 smallint, f7 tinyint, f8 bool, f9 binary(64), f10 nchar(64))");
+            stmt.executeUpdate("insert into weather(ts, f1) values(now+1s, " + TimestampUtil.datetimeToLong("2021-04-21 12:00:00.000") + ")");
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            rs.next();
+
+            Assert.assertEquals("2021-04-21 12:00:00.000", TimestampUtil.longToDatetime(rs.getTimestamp(2).getTime()));
+            Assert.assertEquals(true, rs.getInt(3) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getLong(4) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getFloat(5) == 0.0f && rs.wasNull());
+            Assert.assertEquals(true, rs.getDouble(6) == 0.0f && rs.wasNull());
+            Assert.assertEquals(true, rs.getByte(7) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getShort(8) == 0 && rs.wasNull());
+            Assert.assertEquals(null, rs.getBytes(9));
+            Assert.assertEquals(null, rs.getString(10));
+
+            rs.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testJNI() throws SQLException {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        conn_jni = DriverManager.getConnection(url, properties);
+
+        try (Statement stmt = conn_jni.createStatement()) {
+            stmt.execute("drop database if exists test_null");
+            stmt.execute("create database if not exists test_null");
+            stmt.execute("use test_null");
+            stmt.execute("create table weather(ts timestamp, f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 smallint, f7 tinyint, f8 bool, f9 binary(64), f10 nchar(64))");
+            stmt.executeUpdate("insert into weather(ts, f1) values(now+1s, " + TimestampUtil.datetimeToLong("2021-04-21 12:00:00.000") + ")");
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            rs.next();
+
+            Assert.assertEquals("2021-04-21 12:00:00.000", TimestampUtil.longToDatetime(rs.getTimestamp(2).getTime()));
+            Assert.assertEquals(true, rs.getInt(3) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getLong(4) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getFloat(5) == 0.0f && rs.wasNull());
+            Assert.assertEquals(true, rs.getDouble(6) == 0.0f && rs.wasNull());
+            Assert.assertEquals(true, rs.getByte(7) == 0 && rs.wasNull());
+            Assert.assertEquals(true, rs.getShort(8) == 0 && rs.wasNull());
+            Assert.assertEquals(null, rs.getBytes(9));
+            Assert.assertEquals(null, rs.getString(10));
+
+            rs.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @BeforeClass
+    public static void beforeClass() {
+        properties = new Properties();
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+    }
+
+    @AfterClass
+    public static void afterClass() throws SQLException {
+        if (conn_restful != null)
+            conn_restful.close();
+        if (conn_jni != null)
+            conn_jni.close();
+    }
+}

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",

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

src/cq/src/cqMain.c

@@ -310,8 +310,23 @@ void *cqCreate(void *handle, uint64_t uid, int32_t sid, const char* dstTable, ch
   }
   SCqContext *pContext = handle;
   int64_t rid = 0;
+
+  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;
+  }
   
-  SCqObj *pObj = calloc(sizeof(SCqObj), 1);
+  pthread_mutex_unlock(&pContext->mutex);
+  
+  pObj = calloc(sizeof(SCqObj), 1);
   if (pObj == NULL) return NULL;
 
   pObj->uid = uid;
@@ -386,12 +401,15 @@ static void doCreateStream(void *param, TAOS_RES *result, int32_t code) {
   if (pObj == NULL) {
     return;
   }
-  
+
   SCqContext* pContext = pObj->pContext;
-  SSqlObj* pSql = (SSqlObj*)result;
+  SSqlObj* pSql = (SSqlObj*)result;  
-  if (atomic_val_compare_exchange_ptr(&(pContext->dbConn), NULL, pSql->pTscObj) != NULL) {
+  if (code == TSDB_CODE_SUCCESS) {
-    taos_close(pSql->pTscObj);
+    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) {

src/inc/taosdef.h

@@ -247,8 +247,9 @@ do { \
 #define TSDB_MAX_REPLICA          5
 
 #define TSDB_TBNAME_COLUMN_INDEX        (-1)
-#define TSDB_BLOCK_DIST_COLUMN_INDEX     (-2)
+#define TSDB_BLOCK_DIST_COLUMN_INDEX    (-2)
-#define TSDB_UD_COLUMN_INDEX            (-100)
+#define TSDB_UD_COLUMN_INDEX            (-1000)
+#define TSDB_RES_COL_ID                 (-5000)
 
 #define TSDB_MULTI_TABLEMETA_MAX_NUM    100000  // maximum batch size allowed to load table meta
 
@@ -396,9 +397,10 @@ typedef enum {
 typedef enum {
   TSDB_SUPER_TABLE  = 0,   // super table
   TSDB_CHILD_TABLE  = 1,   // table created from super table
-  TSDB_NORMAL_TABLE = 2,  // ordinary table
+  TSDB_NORMAL_TABLE = 2,   // ordinary table
-  TSDB_STREAM_TABLE = 3,  // table created from stream computing
+  TSDB_STREAM_TABLE = 3,   // table created from stream computing
-  TSDB_TABLE_MAX    = 4
+  TSDB_TEMP_TABLE   = 4,   // temp table created by nest query
+  TSDB_TABLE_MAX    = 5
 } ETableType;
 
 typedef enum {

src/inc/taosmsg.h

@@ -76,9 +76,9 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DNODE, "create-dnode" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DNODE, "drop-dnode" )   
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DB, "create-db" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_FUNCTION, "create-function" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DB, "drop-db" )	  
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DB, "drop-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_FUNCTION, "drop-function" )   
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_FUNCTION, "drop-function" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-db" )	 
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-db" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_DB, "alter-db" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_SYNC_DB, "sync-db-replica" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_TABLE, "create-table" )
@@ -402,7 +402,6 @@ typedef struct SColIndex {
   char     name[TSDB_COL_NAME_LEN];  // TODO remove it
 } SColIndex;
 
-
 typedef struct SColumnFilterInfo {
   int16_t lowerRelOptr;
   int16_t upperRelOptr;
@@ -424,42 +423,13 @@ typedef struct SColumnFilterInfo {
   };
 } SColumnFilterInfo;
 
-/* sql function msg, to describe the message to vnode about sql function
+typedef struct SColumnFilterList {
- * operations in select clause */
+  int16_t              numOfFilters;
-typedef struct SSqlFuncMsg {
+  union{
-  int16_t functionId;
+    int64_t placeholder;
-  int16_t numOfParams;
+    SColumnFilterInfo *filterInfo;
-
+  };
-  int16_t resColId;      // result column id, id of the current output column
+} SColumnFilterList;
-  int16_t colType;
-  int16_t colBytes;
-
-  SColIndex colInfo;
-  struct ArgElem {
-    int16_t argType;
-    int16_t argBytes;
-    union {
-      double  d;
-      int64_t i64;
-      char *  pz;
-    } argValue;
-  } arg[3];
-
-  int32_t filterNum;
-  SColumnFilterInfo filterInfo[];
-} SSqlFuncMsg;
-
-
-typedef struct SExprInfo {
-  SColumnFilterInfo * pFilter;
-  struct tExprNode* pExpr;
-  int16_t     bytes;
-  int16_t     type;
-  int32_t     interBytes;
-  int64_t     uid;
-  SSqlFuncMsg base;
-} SExprInfo;
-
 /*
  * for client side struct, we only need the column id, type, bytes are not necessary
  * But for data in vnode side, we need all the following information.
@@ -468,11 +438,7 @@ typedef struct SColumnInfo {
   int16_t            colId;
   int16_t            type;
   int16_t            bytes;
-  int16_t            numOfFilters;
+  SColumnFilterList  flist;
-  union{
-    int64_t placeholder;
-    SColumnFilterInfo *filters;
-  };
 } SColumnInfo;
 
 typedef struct STableIdInfo {
@@ -486,10 +452,29 @@ typedef struct STimeWindow {
   TSKEY ekey;
 } STimeWindow;
 
+typedef struct {
+  int32_t     tsOffset;         // offset value in current msg body, NOTE: ts list is compressed
+  int32_t     tsLen;            // total length of ts comp block
+  int32_t     tsNumOfBlocks;    // ts comp block numbers
+  int32_t     tsOrder;          // ts comp block order
+} STsBufInfo;
+
 typedef struct {
   SMsgHead    head;
   char        version[TSDB_VERSION_LEN];
 
+  bool        stableQuery;      // super table query or not
+  bool        topBotQuery;      // TODO used bitwise flag
+  bool        groupbyColumn;    // denote if this is a groupby normal column query
+  bool        hasTagResults;    // if there are tag values in final result or not
+  bool        timeWindowInterpo;// if the time window start/end required interpolation
+  bool        queryBlockDist;    // if query data block distribution
+  bool        stabledev;        // super table stddev query
+  bool        tsCompQuery;      // is tscomp query
+  bool        simpleAgg;
+  bool        pointInterpQuery; // point interpolation query
+  bool        needReverseScan;  // need reverse scan
+
   STimeWindow window;
   int32_t     numOfTables;
   int16_t     order;
@@ -512,17 +497,16 @@ typedef struct {
   int16_t     fillType;         // interpolate type
   uint64_t    fillVal;          // default value array list
   int32_t     secondStageOutput;
-  int32_t     tsOffset;         // offset value in current msg body, NOTE: ts list is compressed
+  STsBufInfo  tsBuf;            // tsBuf info
-  int32_t     tsLen;            // total length of ts comp block
-  int32_t     tsNumOfBlocks;    // ts comp block numbers
-  int32_t     tsOrder;          // ts comp block order
   int32_t     numOfTags;        // number of tags columns involved
   int32_t     sqlstrLen;        // sql query string
   int32_t     prevResultLen;    // previous result length
+  int32_t     numOfOperator;
+  int32_t     tableScanOperator;// table scan operator. -1 means no scan operator
   int32_t     udfNum;           // number of udf function
   int32_t     udfContentOffset;
   int32_t     udfContentLen;
-  SColumnInfo colList[];
+  SColumnInfo tableCols[];
 } SQueryTableMsg;
 
 typedef struct {
@@ -868,7 +852,7 @@ typedef struct {
   uint32_t queryId;
   int64_t  useconds;
   int64_t  stime;
-  uint64_t qHandle;
+  uint64_t qId;
 } SQueryDesc;
 
 typedef struct {

src/inc/tsdb.h

@@ -221,7 +221,7 @@ typedef struct {
 
 typedef struct {
   uint32_t  numOfTables;
-  SArray *  pGroupList;
+  SArray   *pGroupList;
   SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
 } STableGroupInfo;
 

src/inc/ttokendef.h

@@ -209,27 +209,6 @@
 #define TK_INTO                           190
 #define TK_VALUES                         191
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302

src/kit/shell/src/shellWindows.c

@@ -199,15 +199,19 @@ void updateBuffer(Command *cmd) {
 }
 
 int isReadyGo(Command *cmd) {
-  char total[MAX_COMMAND_SIZE];
+  char *total = malloc(MAX_COMMAND_SIZE);
   memset(total, 0, MAX_COMMAND_SIZE);
   sprintf(total, "%s%s", cmd->buffer, cmd->command);
 
   char *reg_str =
       "(^.*;\\s*$)|(^\\s*$)|(^\\s*exit\\s*$)|(^\\s*q\\s*$)|(^\\s*quit\\s*$)|(^"
       "\\s*clear\\s*$)";
-  if (regex_match(total, reg_str, REG_EXTENDED | REG_ICASE)) return 1;
+  if (regex_match(total, reg_str, REG_EXTENDED | REG_ICASE)) {
+    free(total);
+    return 1;
+  }
 
+  free(total);
   return 0;
 }
 

src/kit/taosdump/taosdump.c

@@ -214,8 +214,8 @@ static struct argp_option options[] = {
   // dump format options
   {"schemaonly",    's', 0,             0,  "Only dump schema.",                                            3},
   {"with-property", 'M', 0,             0,  "Dump schema with properties.",                                 3},
-  {"start-time",    'S', "START_TIME",  0,  "Start time to dump.",                                          3},
+  {"start-time",    'S', "START_TIME",  0,  "Start time to dump. Either Epoch or ISO8601/RFC3339 format is acceptable. Epoch precision millisecond. ISO8601 format example: 2017-10-01T18:00:00.000+0800 or 2017-10-0100:00:00.000+0800 or '2017-10-01 00:00:00.000+0800'",  3},
-  {"end-time",      'E', "END_TIME",    0,  "End time to dump. Epoch or ISO8601/RFC3339 format is acceptable. For example: 2017-10-01T18:00:00+0800",  3},
+  {"end-time",      'E', "END_TIME",    0,  "End time to dump. Either Epoch or ISO8601/RFC3339 format is acceptable. Epoch precision millisecond. ISO8601 format example: 2017-10-01T18:00:00.000+0800 or 2017-10-0100:00:00.000+0800 or '2017-10-01 00:00:00.000+0800'",  3},
   {"data-batch",    'N', "DATA_BATCH",  0,  "Number of data point per insert statement. Default is 1.",     3},
   {"max-sql-len",   'L', "SQL_LEN",     0,  "Max length of one sql. Default is 65480.",                     3},
   {"table-batch",   't', "TABLE_BATCH", 0,  "Number of table dumpout into one output file. Default is 1.",  3},
@@ -482,7 +482,8 @@ static int queryDbImpl(TAOS *taos, char *command) {
 
 static void parse_args(int argc, char *argv[], SArguments *arguments) {
   for (int i = 1; i < argc; i++) {
-    if (strcmp(argv[i], "-E") == 0) {
+    if ((strcmp(argv[i], "-S") == 0)
+        || (strcmp(argv[i], "-E") == 0)) {
       if (argv[i+1]) {
         char *tmp = strdup(argv[++i]);
 
@@ -509,7 +510,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
           exit(-1);
         }
       } else {
-        errorPrint("%s() LN%d, -E need a valid value following!\n", __func__, __LINE__);
+        errorPrint("%s need a valid value following!\n", argv[i]);
         exit(-1);
       }
     } else if (strcmp(argv[i], "-g") == 0) {
@@ -522,7 +523,8 @@ int main(int argc, char *argv[]) {
 
   /* Parse our arguments; every option seen by parse_opt will be
      reflected in arguments. */
-  parse_args(argc, argv, &g_args);
+  if (argc > 1)
+    parse_args(argc, argv, &g_args);
 
   argp_parse(&argp, argc, argv, 0, 0, &g_args);
 

src/mnode/src/mnodeProfile.c

@@ -344,7 +344,7 @@ static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC
 
   pShow->bytes[cols] = 24;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "qhandle");
+  strcpy(pSchema[cols].name, "qid");
   pSchema[cols].bytes = htons(pShow->bytes[cols]);
   cols++;
 
@@ -420,7 +420,7 @@ static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, v
       cols++;
 
       char handleBuf[24] = {0};
-      snprintf(handleBuf, tListLen(handleBuf), "%p", (void*)htobe64(pDesc->qHandle));
+      snprintf(handleBuf, tListLen(handleBuf), "%"PRIu64, htobe64(pDesc->qId));
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
 
       STR_WITH_MAXSIZE_TO_VARSTR(pWrite, handleBuf, pShow->bytes[cols]);

src/os/inc/os.h

@@ -32,6 +32,10 @@ extern "C" {
 #include "osArm32.h"
 #endif
 
+#ifdef _TD_MIPS_64
+#include "osMips64.h"
+#endif
+
 #ifdef _TD_LINUX_64
 #include "osLinux64.h"
 #endif

src/os/inc/osMips64.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_MIPS64_H
+#define TDENGINE_OS_MIPS64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <argp.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <error.h>
+#include <linux/sysctl.h>
+#include <math.h>
+#include <poll.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/src/darwin/darwinSysInfo.c

@@ -217,7 +217,7 @@ void taosSetCoreDump() {}
 
 int32_t taosGetDiskSize(char *dataDir, SysDiskSize *diskSize) {
   struct statvfs info;
-  if (statvfs(tsDataDir, &info)) {
+  if (statvfs(dataDir, &info)) {
     uError("failed to get disk size, dataDir:%s errno:%s", tsDataDir, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;

src/os/src/detail/osSysinfo.c

@@ -319,7 +319,7 @@ bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
 
 int32_t taosGetDiskSize(char *dataDir, SysDiskSize *diskSize) {
   struct statvfs info;
-  if (statvfs(tsDataDir, &info)) {
+  if (statvfs(dataDir, &info)) {
     uError("failed to get disk size, dataDir:%s errno:%s", tsDataDir, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;

src/os/tests/test.cpp

@@ -18,7 +18,7 @@ TEST(testCase, parse_time) {
   deltaToUtcInitOnce();
 
   // window: 1500000001000, 1500002000000
-  // pQuery->interval: interval: 86400000, sliding:3600000
+  // pQueryAttr->interval: interval: 86400000, sliding:3600000
   int64_t key = 1500000001000;
   SInterval interval = {0};
   interval.interval = 86400000;

src/plugins/http/inc/httpContext.h

@@ -25,7 +25,7 @@ const char *httpContextStateStr(HttpContextState state);
 HttpContext *httpCreateContext(SOCKET fd);
 bool         httpInitContext(HttpContext *pContext);
 HttpContext *httpGetContext(void * pContext);
-void         httpReleaseContext(HttpContext *pContext, bool clearRes);
+void         httpReleaseContext(HttpContext *pContext/*, bool clearRes*/);
 void         httpCloseContextByServer(HttpContext *pContext);
 void         httpCloseContextByApp(HttpContext *pContext);
 void         httpNotifyContextClose(HttpContext *pContext);

src/plugins/http/src/httpContext.c

@@ -146,20 +146,20 @@ HttpContext *httpGetContext(void *ptr) {
   return NULL;
 }
 
-void httpReleaseContext(HttpContext *pContext, bool clearRes) {
+void httpReleaseContext(HttpContext *pContext/*, bool clearRes*/) {
   int32_t refCount = atomic_sub_fetch_32(&pContext->refCount, 1);
   if (refCount < 0) {
     httpError("context:%p, is already released, refCount:%d", pContext, refCount);
     return;
   }
-
+  /*
   if (clearRes) {
     if (pContext->parser) {
       httpClearParser(pContext->parser);
     }
     memset(&pContext->singleCmd, 0, sizeof(HttpSqlCmd));
   }
-
+  */
   HttpContext **ppContext = pContext->ppContext;
   httpTrace("context:%p, is released, data:%p refCount:%d", pContext, ppContext, refCount);
 
@@ -217,7 +217,7 @@ void httpCloseContextByApp(HttpContext *pContext) {
               httpContextStateStr(pContext->state), pContext->state);
   }
 
-  httpReleaseContext(pContext, true);
+  httpReleaseContext(pContext/*, true*/);
 }
 
 void httpCloseContextByServer(HttpContext *pContext) {
@@ -235,5 +235,5 @@ void httpCloseContextByServer(HttpContext *pContext) {
 
   pContext->parsed = false;
   httpRemoveContextFromEpoll(pContext);
-  httpReleaseContext(pContext, true);
+  httpReleaseContext(pContext/*, true*/);
 }

src/plugins/http/src/httpHandle.c

@@ -50,6 +50,7 @@ bool httpProcessData(HttpContext* pContext) {
        */
       // httpCloseContextByApp(pContext);
     } else {
+      httpClearParser(pContext->parser);
       httpProcessRequest(pContext);
     }
   }

src/plugins/http/src/httpServer.c

@@ -177,7 +177,7 @@ static void httpProcessHttpData(void *param) {
       if (!httpAlterContextState(pContext, HTTP_CONTEXT_STATE_READY, HTTP_CONTEXT_STATE_READY)) {
         httpDebug("context:%p, fd:%d, state:%s, not in ready state, ignore read events", pContext, pContext->fd,
                   httpContextStateStr(pContext->state));
-        httpReleaseContext(pContext, true);
+        httpReleaseContext(pContext/*, true*/);
         continue;
       }
 
@@ -191,7 +191,7 @@ static void httpProcessHttpData(void *param) {
           (*(pThread->processData))(pContext);
           atomic_fetch_add_32(&pServer->requestNum, 1);
         } else {
-          httpReleaseContext(pContext, false);
+          httpReleaseContext(pContext/*, false*/);
         }
       }
     }
@@ -275,7 +275,7 @@ static void *httpAcceptHttpConnection(void *arg) {
       httpError("context:%p, fd:%d, ip:%s, thread:%s, failed to add http fd for epoll, error:%s", pContext, connFd,
                 pContext->ipstr, pThread->label, strerror(errno));
       taosCloseSocket(pContext->fd);
-      httpReleaseContext(pContext, true);
+      httpReleaseContext(pContext/*, true*/);
       continue;
     }
 

src/plugins/http/src/httpSql.c

@@ -376,6 +376,8 @@ void httpExecCmd(HttpContext *pContext) {
       httpCloseContextByApp(pContext);
       break;
   }
+
+  memset(&pContext->singleCmd, 0, sizeof(HttpSqlCmd));
 }
 
 void httpProcessRequestCb(void *param, TAOS_RES *result, int32_t code) {

src/query/inc/qAggMain.h

@@ -123,7 +123,7 @@ enum {
 #define QUERY_IS_FREE_RESOURCE(type)     (((type)&TSDB_QUERY_TYPE_FREE_RESOURCE) != 0)
 
 typedef struct SArithmeticSupport {
-  SExprInfo   *pArithExpr;
+  SExprInfo   *pExprInfo;
   int32_t      numOfCols;
   SColumnInfo *colList;
   void        *exprList;   // client side used
@@ -211,9 +211,6 @@ typedef struct SAggFunctionInfo {
   void (*xFunction)(SQLFunctionCtx *pCtx);                     // blocks version function
   void (*xFunctionF)(SQLFunctionCtx *pCtx, int32_t position);  // single-row function version, todo merge with blockwise function
 
-  // some sql function require scan data twice or more, e.g.,stddev, percentile
-  void (*xNextStep)(SQLFunctionCtx *pCtx);
-
   // finalizer must be called after all xFunction has been executed to generated final result.
   void (*xFinalize)(SQLFunctionCtx *pCtx);
   void (*mergeFunc)(SQLFunctionCtx *pCtx);

src/query/inc/qExecutor.h

@@ -87,7 +87,7 @@ typedef struct SResultRow {
   bool          closed;      // this result status: closed or opened
   uint32_t      numOfRows;   // number of rows of current time window
   SResultRowCellInfo*  pCellInfo;  // For each result column, there is a resultInfo
-  STimeWindow win; 
+  STimeWindow win;
   char* key;                 // start key of current result row
 } SResultRow;
 
@@ -179,8 +179,11 @@ typedef struct SSDataBlock {
   SDataBlockInfo info;
 } SSDataBlock;
 
-typedef struct SQuery {
+// The basic query information extracted from the SQueryInfo tree to support the
+// execution of query in a data node.
+typedef struct SQueryAttr {
   SLimitVal        limit;
+  SLimitVal        slimit;
 
   bool             stableQuery;      // super table query or not
   bool             topBotQuery;      // TODO used bitwise flag
@@ -189,6 +192,11 @@ typedef struct SQuery {
   bool             timeWindowInterpo;// if the time window start/end required interpolation
   bool             queryBlockDist;    // if query data block distribution
   bool             stabledev;        // super table stddev query
+  bool             tsCompQuery;      // is tscomp query
+  bool             simpleAgg;
+  bool             pointInterpQuery; // point interpolation query
+  bool             needReverseScan;  // need reverse scan
+  bool             distinctTag;      // distinct tag query
   int32_t          interBufSize;     // intermediate buffer sizse
 
   int32_t          havingNum;        // having expr number
@@ -203,39 +211,41 @@ typedef struct SQuery {
   int16_t          precision;
   int16_t          numOfOutput;
   int16_t          fillType;
-  int16_t          checkResultBuf;   // check if the buffer is full during scan each block
 
   int32_t          srcRowSize;       // todo extract struct
   int32_t          resultRowSize;
   int32_t          intermediateResultRowSize; // intermediate result row size, in case of top-k query.
-  int32_t          maxSrcColumnSize;
+  int32_t          maxTableColumnWidth;
   int32_t          tagLen;           // tag value length of current query
   SSqlGroupbyExpr* pGroupbyExpr;
+
   SExprInfo*       pExpr1;
   SExprInfo*       pExpr2;
   int32_t          numOfExpr2;
-  SColumnInfo*     colList;
+  SExprInfo*       pExpr3;
+  int32_t          numOfExpr3;
+
+  SColumnInfo*     tableCols;
   SColumnInfo*     tagColList;
   int32_t          numOfFilterCols;
   int64_t*         fillVal;
   SOrderedPrjQueryInfo prjInfo;        // limit value for each vgroup, only available in global order projection query.
   SSingleColumnFilterInfo* pFilterInfo;
 
-  STableQueryInfo* current;
   void*            tsdb;
   SMemRef          memRef;
   STableGroupInfo  tableGroupInfo;       // table <tid, last_key> list  SArray<STableKeyInfo>
   int32_t          vgId;
-} SQuery;
+} SQueryAttr;
 
-typedef SSDataBlock* (*__operator_fn_t)(void* param);
+typedef SSDataBlock* (*__operator_fn_t)(void* param, bool* newgroup);
 typedef void (*__optr_cleanup_fn_t)(void* param, int32_t num);
 
 struct SOperatorInfo;
 
 typedef struct SQueryRuntimeEnv {
   jmp_buf               env;
-  SQuery*               pQuery;
+  SQueryAttr*           pQueryAttr;
   uint32_t              status;           // query status
   void*                 qinfo;
   uint8_t               scanFlag;         // denotes reversed scan of data or not
@@ -258,10 +268,10 @@ typedef struct SQueryRuntimeEnv {
   SSDataBlock          *outputBuf;
   STableGroupInfo       tableqinfoGroupInfo;  // this is a group array list, including SArray<STableQueryInfo*> structure
   struct SOperatorInfo *proot;
-  struct SOperatorInfo *pTableScanner;   // table scan operator
   SGroupResInfo         groupResInfo;
   int64_t               currentOffset;   // dynamic offset value
 
+  STableQueryInfo      *current;
   SRspResultInfo        resultInfo;
   SHashObj             *pTableRetrieveTsMap;
   SUdfInfo             *pUdfInfo;
@@ -283,13 +293,17 @@ enum OPERATOR_TYPE_E {
   OP_Arithmetic        = 7,
   OP_Groupby           = 8,
   OP_Limit             = 9,
-  OP_Offset            = 10,
+  OP_SLimit            = 10,
   OP_TimeWindow        = 11,
   OP_SessionWindow     = 12,
   OP_Fill              = 13,
   OP_MultiTableAggregate     = 14,
   OP_MultiTableTimeInterval  = 15,
-  OP_Having            = 16,
+  OP_DummyInput        = 16,   //TODO remove it after fully refactor.
+  OP_MultiwayMergeSort      = 17,   // multi-way data merge into one input stream.
+  OP_GlobalAggregate   = 18,   // global merge for the multi-way data sources.
+  OP_Filter            = 19,
+  OP_Distinct          = 20,
 };
 
 typedef struct SOperatorInfo {
@@ -312,6 +326,12 @@ enum {
   QUERY_RESULT_READY     = 2,
 };
 
+typedef struct {
+  int32_t      numOfTags;
+  int32_t      numOfCols;
+  SColumnInfo *colList;
+} SQueriedTableInfo;
+
 typedef struct SQInfo {
   void*            signature;
   uint64_t         qId;
@@ -319,7 +339,7 @@ typedef struct SQInfo {
   int64_t          owner;       // if it is in execution
 
   SQueryRuntimeEnv runtimeEnv;
-  SQuery           query;
+  SQueryAttr       query;
   void*            pBuf;        // allocated buffer for STableQueryInfo, sizeof(STableQueryInfo)*numOfTables;
 
   pthread_mutex_t  lock;        // used to synchronize the rsp/query threads
@@ -337,14 +357,16 @@ typedef struct SQueryParam {
   char            *tbnameCond;
   char            *prevResult;
   SArray          *pTableIdList;
-  SSqlFuncMsg    **pExprMsg;
+  SSqlExpr       **pExpr;
-  SSqlFuncMsg    **pSecExprMsg;
+  SSqlExpr       **pSecExpr;
   SExprInfo       *pExprs;
   SExprInfo       *pSecExprs;
 
   SColIndex       *pGroupColIndex;
   SColumnInfo     *pTagColumnInfo;
   SSqlGroupbyExpr *pGroupbyExpr;
+  int32_t          tableScanOperator;
+  SArray          *pOperator;
   SUdfInfo        *pUdfInfo;
 } SQueryParam;
 
@@ -397,26 +419,39 @@ typedef struct SArithOperatorInfo {
   SOptrBasicInfo binfo;
   int32_t        bufCapacity;
   uint32_t       seed;
+
+  SSDataBlock   *existDataBlock;
 } SArithOperatorInfo;
 
 typedef struct SLimitOperatorInfo {
-  int64_t limit;
+  int64_t   limit;
-  int64_t total;
+  int64_t   total;
 } SLimitOperatorInfo;
 
-typedef struct SOffsetOperatorInfo {
+typedef struct SSLimitOperatorInfo {
-  int64_t offset;
+  int64_t   groupTotal;
-} SOffsetOperatorInfo;
+  int64_t   currentGroupOffset;
 
-typedef struct SHavingOperatorInfo {  
+  int64_t   rowsTotal;
-  SArray* fp;
+  int64_t   currentOffset;
-} SHavingOperatorInfo;
+  SLimitVal limit;
+  SLimitVal slimit;
 
+  char    **prevRow;
+  SArray   *orderColumnList;
+} SSLimitOperatorInfo;
+
+typedef struct SFilterOperatorInfo {
+  SSingleColumnFilterInfo *pFilterInfo;
+  int32_t numOfFilterCols;
+} SFilterOperatorInfo;
 
 typedef struct SFillOperatorInfo {
   SFillInfo   *pFillInfo;
   SSDataBlock *pRes;
   int64_t      totalInputRows;
+
+  SSDataBlock *existNewGroupBlock;
 } SFillOperatorInfo;
 
 typedef struct SGroupbyOperatorInfo {
@@ -433,27 +468,97 @@ typedef struct SSWindowOperatorInfo {
   int32_t        start;      // start row index
 } SSWindowOperatorInfo;
 
+typedef struct SDistinctOperatorInfo {
+  SHashObj         *pSet;
+  SSDataBlock      *pRes;
+  bool              recordNullVal;  //has already record the null value, no need to try again
+  int64_t           threshold;
+  int64_t           outputCapacity;
+} SDistinctOperatorInfo;
+
+struct SLocalMerger;
+
+typedef struct SMultiwayMergeInfo {
+  struct SLocalMerger *pMerge;
+  SOptrBasicInfo       binfo;
+  int32_t              bufCapacity;
+  int64_t              seed;
+  char               **prevRow;
+  SArray              *orderColumnList;
+  int32_t              resultRowFactor;
+
+  bool                 hasGroupColData;
+  char               **currentGroupColData;
+  SArray              *groupColumnList;
+  bool                 hasDataBlockForNewGroup;
+  SSDataBlock         *pExistBlock;
+
+  bool                 hasPrev;
+  bool                 groupMix;
+} SMultiwayMergeInfo;
+
+SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);
+SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime);
+SOperatorInfo* createTableSeqScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
+
+SOperatorInfo* createAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream);
+SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
+SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
+                                              int32_t numOfRows, void* merger, bool groupMix);
+SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param);
+SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
+SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+
+SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
+SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
+SSDataBlock* doSLimit(void* param, bool* newgroup);
+
+SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
+void* destroyOutputBuf(SSDataBlock* pBlock);
+
+void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order);
+int32_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput);
+void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset);
+void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOfInputRows);
+
 void freeParam(SQueryParam *param);
 int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param);
-int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo, SSqlFuncMsg **pExprMsg,
+int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
-                                   SColumnInfo* pTagCols, SUdfInfo* pUdfInfo);
+                        SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg, SUdfInfo* pUdfInfo);
+
 int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
-                                           SSqlFuncMsg **pExprMsg, SExprInfo *prevExpr, SUdfInfo *pUdfInfo);
+                                           SSqlExpr **pExpr, SExprInfo *prevExpr, SUdfInfo *pUdfInfo);
 
 SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
 SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
                         SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, bool stableQuery, char* sql, uint64_t *qId, SUdfInfo* pUdfInfo);
-int32_t initQInfo(SQueryTableMsg *pQueryMsg, void *tsdb, int32_t vgId, SQInfo *pQInfo, SQueryParam* param, bool isSTable);
+
+int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
+                  int32_t prevResultLen, void* merger);
+
 void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters);
 
+STableQueryInfo *createTableQueryInfo(SQueryAttr* pQueryAttr, void* pTable, bool groupbyColumn, STimeWindow win, void* buf);
+int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, void *pQueryMsg);
+
 bool isQueryKilled(SQInfo *pQInfo);
 int32_t checkForQueryBuf(size_t numOfTables);
 bool doBuildResCheck(SQInfo* pQInfo);
 void setQueryStatus(SQueryRuntimeEnv *pRuntimeEnv, int8_t status);
 
+bool onlyQueryTags(SQueryAttr* pQueryAttr);
 void destroyUdfInfo(SUdfInfo* pUdfInfo);
 
-bool onlyQueryTags(SQuery* pQuery);
 bool isValidQInfo(void *param);
 
 int32_t doDumpQueryResult(SQInfo *pQInfo, char *data);
@@ -462,6 +567,7 @@ size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows);
 void setQueryKilled(SQInfo *pQInfo);
 void queryCostStatis(SQInfo *pQInfo);
 void freeQInfo(SQInfo *pQInfo);
+void freeQueryAttr(SQueryAttr *pQuery);
 
 int32_t getMaximumIdleDurationSec();
 

src/query/inc/qExtbuffer.h

@@ -237,6 +237,11 @@ int32_t compare_a(tOrderDescriptor *, int32_t numOfRow1, int32_t s1, char *data1
 int32_t compare_d(tOrderDescriptor *, int32_t numOfRow1, int32_t s1, char *data1, int32_t numOfRow2, int32_t s2,
                   char *data2);
 
+struct SSDataBlock;
+int32_t compare_aRv(struct SSDataBlock* pBlock, SArray* colIndex, int32_t numOfCols, int32_t rowIndex, char** buffer, int32_t order);
+
+int32_t columnValueAscendingComparator(char *f1, char *f2, int32_t type, int32_t bytes);
+
 #ifdef __cplusplus
 }
 #endif

src/query/inc/qPlan.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_QPLAN_H
+#define TDENGINE_QPLAN_H
+
+//TODO refactor
+SArray* createTableScanPlan(SQueryAttr* pQueryAttr);
+SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr);
+SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr);
+
+#endif  // TDENGINE_QPLAN_H

src/query/inc/qSqlparser.h

@@ -40,8 +40,14 @@ enum SQL_NODE_TYPE {
 };
 
 enum SQL_NODE_FROM_TYPE {
-  SQL_NODE_FROM_SUBQUERY  = 1,
+  SQL_NODE_FROM_SUBQUERY   = 1,
-  SQL_NODE_FROM_NAMELIST  = 2,
+  SQL_NODE_FROM_TABLELIST  = 2,
+};
+
+enum SQL_EXPR_FLAG {
+  EXPR_FLAG_TS_ERROR = 1,
+  EXPR_FLAG_US_TIMESTAMP = 2,
+  EXPR_FLAG_TIMESTAMP_VAR = 3,
 };
 
 extern char tTokenTypeSwitcher[13];
@@ -83,11 +89,11 @@ typedef struct SSessionWindowVal {
   SStrToken          gap;
 } SSessionWindowVal;
 
-struct SFromInfo;
+struct SRelationInfo;
 
-typedef struct SQuerySqlNode {
+typedef struct SSqlNode {
-  struct SArray     *pSelectList;  // select clause
+  struct SArray     *pSelNodeList; // select clause
-  struct SFromInfo  *from;         // from clause SArray<SQuerySqlNode>
+  struct SRelationInfo  *from;     // from clause SArray<SSqlNode>
   struct tSqlExpr   *pWhere;       // where clause [optional]
   SArray            *pGroupby;     // groupby clause, only for tags[optional], SArray<tVariantListItem>
   SArray            *pSortOrder;   // orderby [optional],  SArray<tVariantListItem>
@@ -99,25 +105,17 @@ typedef struct SQuerySqlNode {
   SLimitVal          slimit;       // group limit offset [optional]
   SStrToken          sqlstr;       // sql string in select clause
   struct tSqlExpr   *pHaving;      // having clause [optional]
-} SQuerySqlNode;
+} SSqlNode;
 
 typedef struct STableNamePair {
   SStrToken name;
   SStrToken aliasName;
 } STableNamePair;
 
-typedef struct SSubclauseInfo {  // "UNION" multiple select sub-clause
+typedef struct SRelationInfo {
-  SQuerySqlNode    **pClause;
+  int32_t       type;        // nested query|table name list
-  int32_t            numOfClause;
+  SArray       *list;        // SArray<STableNamePair>|SArray<SSqlNode*>
-} SSubclauseInfo;
+} SRelationInfo;
-
-typedef struct SFromInfo {
-  int32_t            type;        // nested query|table name list
-  union {
-    SSubclauseInfo  *pNode;
-    SArray          *tableList;   // SArray<STableNamePair>
-  };
-} SFromInfo;
 
 typedef struct SCreatedTableInfo {
   SStrToken          name;        // table name token
@@ -140,7 +138,7 @@ typedef struct SCreateTableSql {
   } colInfo;
 
   SArray            *childTableInfo;        // SArray<SCreatedTableInfo>
-  SQuerySqlNode     *pSelect;
+  SSqlNode     *pSelect;
 } SCreateTableSql;
 
 typedef struct SAlterTableInfo {
@@ -227,7 +225,7 @@ typedef struct SMiscInfo {
 typedef struct SSqlInfo {
   int32_t            type;
   bool               valid;
-  SSubclauseInfo     subclauseInfo;
+  SArray            *list;    // todo refactor
   char               msg[256];
   union {
     SCreateTableSql *pCreateTableInfo;
@@ -247,7 +245,8 @@ typedef struct tSqlExpr {
   SStrToken          colInfo;     // table column info
   tVariant           value;       // the use input value
   SStrToken          token;       // original sql expr string
-
+  uint32_t           flags;
+  
   struct tSqlExpr   *pLeft;       // left child
   struct tSqlExpr   *pRight;      // right child
   struct SArray     *pParam;      // function parameters list
@@ -264,14 +263,9 @@ SArray *tVariantListAppend(SArray *pList, tVariant *pVar, uint8_t sortOrder);
 SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
-tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType);
+SRelationInfo *setTableNameList(SRelationInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
-
+SRelationInfo *setSubquery(SRelationInfo* pFromInfo, SArray* pSqlNode);
-int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right);
+void          *destroyRelationInfo(SRelationInfo* pFromInfo);
-
-tSqlExpr *tSqlExprClone(tSqlExpr *pSrc);
-SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
-SFromInfo *setSubquery(SFromInfo* pFromInfo, SQuerySqlNode *pSqlNode);
-void      *destroyFromInfo(SFromInfo* pFromInfo);
 
 // sql expr leaf node
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
@@ -286,23 +280,23 @@ void      tSqlExprDestroy(tSqlExpr *pExpr);
 SArray   *tSqlExprListAppend(SArray *pList, tSqlExpr *pNode, SStrToken *pDistinct, SStrToken *pToken);
 void      tSqlExprListDestroy(SArray *pList);
 
-SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SFromInfo *pFrom, tSqlExpr *pWhere,
+SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *ps,
                                 SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pgLimit, tSqlExpr *pHaving);
+int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right);
 
-SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type);
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SSqlNode *pSelect, int32_t type);
 
 SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
 SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNames, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
-void destroyAllSelectClause(SSubclauseInfo *pSql);
+void destroyAllSqlNode(SArray *pSqlNode);
-void destroyQuerySqlNode(SQuerySqlNode *pSql);
+void destroySqlNode(SSqlNode *pSql);
 void freeCreateTableInfo(void* p);
 
-SSqlInfo       *setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
+SSqlInfo *setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
-SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
+SArray   *setSubclause(SArray *pList, void *pSqlNode);
-
+SArray   *appendSelectClause(SArray *pList, void *pSubclause);
-SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
 
 void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
 

src/query/inc/qUtil.h

@@ -28,9 +28,9 @@
 #define GET_QID(_r)  (((SQInfo*)((_r)->qinfo))->qId)
 
 #define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
-#define GET_ROW_PARAM_FOR_MULTIOUTPUT(_q, tbq, sq) (((tbq) && (!(sq)))? (_q)->pExpr1[1].base.arg->argValue.i64:1)
+#define GET_ROW_PARAM_FOR_MULTIOUTPUT(_q, tbq, sq) (((tbq) && (!(sq)))? (_q)->pExpr1[1].base.param[0].i64:1)
 
-int32_t getOutputInterResultBufSize(SQuery* pQuery);
+int32_t getOutputInterResultBufSize(SQueryAttr* pQueryAttr);
 
 size_t  getResultRowSize(SQueryRuntimeEnv* pRuntimeEnv);
 int32_t initResultRowInfo(SResultRowInfo* pResultRowInfo, int32_t size, int16_t type);
@@ -52,20 +52,11 @@ static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int
   return pResultRowInfo->pResult[slot];
 }
 
-static FORCE_INLINE char* getPosInResultPage(SQueryRuntimeEnv* pRuntimeEnv, tFilePage* page, int32_t rowOffset,
+static FORCE_INLINE char *getPosInResultPage(SQueryAttr *pQueryAttr, tFilePage* page, int32_t rowOffset, int16_t offset) {
-                                             int16_t offset, int32_t size) {
+  assert(rowOffset >= 0 && pQueryAttr != NULL);
-  assert(rowOffset >= 0 && pRuntimeEnv != NULL);
 
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  int32_t numOfRows = (int32_t)GET_ROW_PARAM_FOR_MULTIOUTPUT(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery);
-  int64_t pageSize = pRuntimeEnv->pResultBuf->pageSize;
+  return ((char *)page->data) + rowOffset + offset * numOfRows;
-
-  int32_t numOfRows = (int32_t)GET_ROW_PARAM_FOR_MULTIOUTPUT(pQuery, pQuery->topBotQuery, pQuery->stableQuery);
-
-  // buffer overflow check
-  int64_t bufEnd = (rowOffset + offset * numOfRows + size);
-  assert(page->num <= pageSize && bufEnd <= page->num);
-
-  return ((char*)page->data) + rowOffset + offset * numOfRows;
 }
 
 bool isNullOperator(SColumnFilterElem *pFilter, const char* minval, const char* maxval, int16_t type);

src/query/inc/sql.y

@@ -457,16 +457,16 @@ tagitem(A) ::= PLUS(X) FLOAT(Y).  {
 }
 
 //////////////////////// The SELECT statement /////////////////////////////////
-%type select {SQuerySqlNode*}
+%type select {SSqlNode*}
-%destructor select {destroyQuerySqlNode($$);}
+%destructor select {destroySqlNode($$);}
 select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
   A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &S, F, &L, &G, N);
 }
 
 select(A) ::= LP select(B) RP. {A = B;}
 
-%type union {SSubclauseInfo*}
+%type union {SArray*}
-%destructor union {destroyAllSelectClause($$);}
+%destructor union {destroyAllSqlNode($$);}
 union(Y) ::= select(X). { Y = setSubclause(NULL, X); }
 union(Y) ::= union(Z) UNION ALL select(X). { Y = appendSelectClause(Z, X); }
 
@@ -512,35 +512,30 @@ distinct(X) ::= DISTINCT(Y). { X = Y;  }
 distinct(X) ::= .            { X.n = 0;}
 
 // A complete FROM clause.
-%type from {SFromInfo*}
+%type from {SRelationInfo*}
+%destructor from {destroyRelationInfo($$);}
 from(A) ::= FROM tablelist(X).                 {A = X;}
-from(A) ::= FROM LP union(Y) RP.               {A = Y;}
+from(A) ::= FROM LP union(Y) RP.               {A = setSubquery(NULL, Y);}
 
-%type tablelist {SArray*}
+%type tablelist {SRelationInfo*}
+%destructor tablelist {destroyRelationInfo($$);}
 tablelist(A) ::= ids(X) cpxName(Y).                     {
-  toTSDBType(X.type);
   X.n += Y.n;
   A = setTableNameList(NULL, &X, NULL);
 }
 
 tablelist(A) ::= ids(X) cpxName(Y) ids(Z).             {
-  toTSDBType(X.type);
-  toTSDBType(Z.type);
   X.n += Y.n;
   A = setTableNameList(NULL, &X, &Z);
 }
 
 tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z).  {
-  toTSDBType(X.type);
   X.n += Z.n;
   A = setTableNameList(Y, &X, NULL);
 }
 
 tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z) ids(F). {
-  toTSDBType(X.type);
-  toTSDBType(F.type);
   X.n += Z.n;
-
   A = setTableNameList(Y, &X, &F);
 }
 
@@ -681,6 +676,8 @@ expr(A) ::= PLUS(X) FLOAT(Y).    { X.n += Y.n; X.type = TK_FLOAT; A = tSqlExprCr
 expr(A) ::= STRING(X).           { A = tSqlExprCreateIdValue(&X, TK_STRING);}
 expr(A) ::= NOW(X).              { A = tSqlExprCreateIdValue(&X, TK_NOW); }
 expr(A) ::= VARIABLE(X).         { A = tSqlExprCreateIdValue(&X, TK_VARIABLE);}
+expr(A) ::= PLUS(X) VARIABLE(Y).   { X.n += Y.n; X.type = TK_VARIABLE; A = tSqlExprCreateIdValue(&X, TK_VARIABLE);}
+expr(A) ::= MINUS(X) VARIABLE(Y).  { X.n += Y.n; X.type = TK_VARIABLE; A = tSqlExprCreateIdValue(&X, TK_VARIABLE);}
 expr(A) ::= BOOL(X).             { A = tSqlExprCreateIdValue(&X, TK_BOOL);}
 expr(A) ::= NULL(X).             { A = tSqlExprCreateIdValue(&X, TK_NULL);}
 

src/query/src/qAggMain.c

@@ -169,7 +169,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     qError("Illegal data type %d or data type length %d", dataType, dataBytes);
     return TSDB_CODE_TSC_INVALID_SQL;
   }
- 
+
 
   if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY ||
       functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAGPRJ ||
@@ -231,10 +231,10 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
         *bytes = pUdfInfo->resBytes;
         *interBytes = *bytes;
       }
-    
+
       return TSDB_CODE_SUCCESS;
     }
-  
+
     if (functionId == TSDB_FUNC_MIN || functionId == TSDB_FUNC_MAX) {
       *type = TSDB_DATA_TYPE_BINARY;
       *bytes = (int16_t)(dataBytes + DATA_SET_FLAG_SIZE);
@@ -289,7 +289,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
       return TSDB_CODE_SUCCESS;
     }
   }
-    
+
   if (functionId == TSDB_FUNC_SUM) {
     if (IS_SIGNED_NUMERIC_TYPE(dataType)) {
       *type = TSDB_DATA_TYPE_BIGINT;
@@ -324,10 +324,10 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     } else {
       *interBytes = *bytes;
     }
-  
+
     return TSDB_CODE_SUCCESS;
   }
-    
+
   if (functionId == TSDB_FUNC_AVG) {
     *type = TSDB_DATA_TYPE_DOUBLE;
     *bytes = sizeof(double);
@@ -404,14 +404,7 @@ int32_t isValidFunction(const char* name, int32_t len) {
   return -1;
 }
 
-// set the query flag to denote that query is completed
-static void no_next_step(SQLFunctionCtx *pCtx) {
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-  pResInfo->complete = true;
-}
-
 static bool function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
-//  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pResultInfo->initialized) {
     return false;
   }
@@ -1569,7 +1562,7 @@ static void stddev_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   }
 }
 
-static void stddev_next_step(SQLFunctionCtx *pCtx) {
+static UNUSED_FUNC void stddev_next_step(SQLFunctionCtx *pCtx) {
   /*
    * the stddevInfo and the average info struct share the same buffer area
    * And the position of each element in their struct is exactly the same matched
@@ -2511,6 +2504,29 @@ static STopBotInfo *getTopBotOutputInfo(SQLFunctionCtx *pCtx) {
   }
 }
 
+
+/*
+ * keep the intermediate results during scan data blocks in the format of:
+ * +-----------------------------------+-------------one value pair-----------+------------next value pair-----------+
+ * |-------------pointer area----------|----ts---+-----+-----n tags-----------|----ts---+-----+-----n tags-----------|
+ * +..[Value Pointer1][Value Pointer2].|timestamp|value|tags1|tags2|....|tagsn|timestamp|value|tags1|tags2|....|tagsn+
+ */
+static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
+  char *tmp = (char *)pTopBotInfo + sizeof(STopBotInfo);
+  pTopBotInfo->res = (tValuePair**) tmp;
+  tmp += POINTER_BYTES * pCtx->param[0].i64;
+
+  size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
+//  assert(pCtx->param[0].i64 > 0);
+
+  for (int32_t i = 0; i < pCtx->param[0].i64; ++i) {
+    pTopBotInfo->res[i] = (tValuePair*) tmp;
+    pTopBotInfo->res[i]->pTags = tmp + sizeof(tValuePair);
+    tmp += size;
+  }
+}
+
+
 bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const char *maxval) {
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pResInfo == NULL) {
@@ -2524,6 +2540,10 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
     return true;
   }
   
+  if ((void *)pTopBotInfo->res[0] != (void *)((char *)pTopBotInfo + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
+    buildTopBotStruct(pTopBotInfo, pCtx);
+  }
+
   tValuePair **pRes = (tValuePair**) pTopBotInfo->res;
   
   if (pCtx->functionId == TSDB_FUNC_TOP) {
@@ -2563,27 +2583,6 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
   }
 }
 
-/*
- * keep the intermediate results during scan data blocks in the format of:
- * +-----------------------------------+-------------one value pair-----------+------------next value pair-----------+
- * |-------------pointer area----------|----ts---+-----+-----n tags-----------|----ts---+-----+-----n tags-----------|
- * +..[Value Pointer1][Value Pointer2].|timestamp|value|tags1|tags2|....|tagsn|timestamp|value|tags1|tags2|....|tagsn+
- */
-static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
-  char *tmp = (char *)pTopBotInfo + sizeof(STopBotInfo);
-  pTopBotInfo->res = (tValuePair**) tmp;
-  tmp += POINTER_BYTES * pCtx->param[0].i64;
-  
-  size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
-//  assert(pCtx->param[0].i64 > 0);
-
-  for (int32_t i = 0; i < pCtx->param[0].i64; ++i) {
-    pTopBotInfo->res[i] = (tValuePair*) tmp;
-    pTopBotInfo->res[i]->pTags = tmp + sizeof(tValuePair);
-    tmp += size;
-  }
-}
-
 static bool top_bottom_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
   if (!function_setup(pCtx, pResInfo)) {
     return false;
@@ -2637,7 +2636,11 @@ static void top_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   
   STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
   assert(pRes->num >= 0);
-  
+
+  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
+    buildTopBotStruct(pRes, pCtx);
+  }
+
   SET_VAL(pCtx, 1, 1);
   TSKEY ts = GET_TS_DATA(pCtx, index);
 
@@ -2938,7 +2941,7 @@ static void percentile_finalizer(SQLFunctionCtx *pCtx) {
   doFinalizer(pCtx);
 }
 
-static void percentile_next_step(SQLFunctionCtx *pCtx) {
+static UNUSED_FUNC void percentile_next_step(SQLFunctionCtx *pCtx) {
   SResultRowCellInfo *    pResInfo = GET_RES_INFO(pCtx);
   SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
 
@@ -3043,7 +3046,7 @@ static void apercentile_func_merge(SQLFunctionCtx *pCtx) {
   
   pInput->pHisto = (SHistogramInfo*) ((char *)pInput + sizeof(SAPercentileInfo));
   pInput->pHisto->elems = (SHistBin*) ((char *)pInput->pHisto + sizeof(SHistogramInfo));
-  
+
   if (pInput->pHisto->numOfElems <= 0) {
     return;
   }
@@ -3062,7 +3065,7 @@ static void apercentile_func_merge(SQLFunctionCtx *pCtx) {
     pHisto->elems = (SHistBin*) ((char *)pHisto + sizeof(SHistogramInfo));
     tHistogramDestroy(&pRes);
   }
-  
+
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   pResInfo->hasResult = DATA_SET_FLAG;
   SET_VAL(pCtx, 1, 1);
@@ -3073,7 +3076,7 @@ static void apercentile_finalizer(SQLFunctionCtx *pCtx) {
   
   SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
   SAPercentileInfo *pOutput = GET_ROWCELL_INTERBUF(pResInfo);
-  
+
   if (pCtx->currentStage == MERGE_STAGE) {
     if (pResInfo->hasResult == DATA_SET_FLAG) {  // check for null
       assert(pOutput->pHisto->numOfElems > 0);
@@ -3108,7 +3111,7 @@ static bool leastsquares_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo
   if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
-  
+
   SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   // 2*3 matrix
@@ -3348,8 +3351,6 @@ static void col_project_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   INC_INIT_VAL(pCtx, 1);
   char *pData = GET_INPUT_DATA(pCtx, index);
   memcpy(pCtx->pOutput, pData, pCtx->inputBytes);
-
-  pCtx->pOutput += pCtx->inputBytes;
 }
 
 /**
@@ -3387,9 +3388,15 @@ static void tag_project_function_f(SQLFunctionCtx *pCtx, int32_t index) {
  * @param pCtx
  * @return
  */
+static void copy_function(SQLFunctionCtx *pCtx);
+
 static void tag_function(SQLFunctionCtx *pCtx) {
   SET_VAL(pCtx, 1, 1);
-  tVariantDump(&pCtx->tag, pCtx->pOutput, pCtx->outputType, true);
+  if (pCtx->currentStage == MERGE_STAGE) {
+    copy_function(pCtx);
+  } else {
+    tVariantDump(&pCtx->tag, pCtx->pOutput, pCtx->outputType, true);
+  }
 }
 
 static void tag_function_f(SQLFunctionCtx *pCtx, int32_t index) {
@@ -3726,7 +3733,7 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
   GET_RES_INFO(pCtx)->numOfRes += pCtx->size;
   SArithmeticSupport *sas = (SArithmeticSupport *)pCtx->param[1].pz;
   
-  arithmeticTreeTraverse(sas->pArithExpr->pExpr, pCtx->size, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
+  arithmeticTreeTraverse(sas->pExprInfo->pExpr, pCtx->size, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
 }
 
 static void arithmetic_function_f(SQLFunctionCtx *pCtx, int32_t index) {
@@ -3734,7 +3741,7 @@ static void arithmetic_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   SArithmeticSupport *sas = (SArithmeticSupport *)pCtx->param[1].pz;
   
   sas->offset = index;
-  arithmeticTreeTraverse(sas->pArithExpr->pExpr, 1, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
+  arithmeticTreeTraverse(sas->pExprInfo->pExpr, 1, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
   
   pCtx->pOutput += pCtx->outputBytes;
 }
@@ -4358,7 +4365,7 @@ static bool ts_comp_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pRe
   if (!function_setup(pCtx, pResInfo)) {
     return false;  // not initialized since it has been initialized
   }
-  
+
   STSCompInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   pInfo->pTSBuf = tsBufCreate(false, pCtx->order);
   pInfo->pTSBuf->tsOrder = pCtx->order;
@@ -4918,7 +4925,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               count_function,
                               count_function_f,
-                              no_next_step,
                               doFinalizer,
                               count_func_merge,
                               countRequired,
@@ -4932,7 +4938,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               sum_function,
                               sum_function_f,
-                              no_next_step,
                               function_finalizer,
                               sum_func_merge,
                               statisRequired,
@@ -4946,7 +4951,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               avg_function,
                               avg_function_f,
-                              no_next_step,
                               avg_finalizer,
                               avg_func_merge,
                               statisRequired,
@@ -4960,7 +4964,6 @@ SAggFunctionInfo aAggs[] = {{
                               min_func_setup,
                               min_function,
                               min_function_f,
-                              no_next_step,
                               function_finalizer,
                               min_func_merge,
                               statisRequired,
@@ -4974,7 +4977,6 @@ SAggFunctionInfo aAggs[] = {{
                               max_func_setup,
                               max_function,
                               max_function_f,
-                              no_next_step,
                               function_finalizer,
                               max_func_merge,
                               statisRequired,
@@ -4988,7 +4990,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               stddev_function,
                               stddev_function_f,
-                              stddev_next_step,
                               stddev_finalizer,
                               noop1,
                               dataBlockRequired,
@@ -5002,7 +5003,6 @@ SAggFunctionInfo aAggs[] = {{
                               percentile_function_setup,
                               percentile_function,
                               percentile_function_f,
-                              percentile_next_step,
                               percentile_finalizer,
                               noop1,
                               dataBlockRequired,
@@ -5016,7 +5016,6 @@ SAggFunctionInfo aAggs[] = {{
                               apercentile_function_setup,
                               apercentile_function,
                               apercentile_function_f,
-                              no_next_step,
                               apercentile_finalizer,
                               apercentile_func_merge,
                               dataBlockRequired,
@@ -5030,7 +5029,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               first_function,
                               first_function_f,
-                              no_next_step,
                               function_finalizer,
                               noop1,
                               firstFuncRequired,
@@ -5044,7 +5042,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               last_function,
                               last_function_f,
-                              no_next_step,
                               function_finalizer,
                               noop1,
                               lastFuncRequired,
@@ -5059,7 +5056,6 @@ SAggFunctionInfo aAggs[] = {{
                               first_last_function_setup,
                               last_row_function,
                               noop2,
-                              no_next_step,
                               last_row_finalizer,
                               last_dist_func_merge,
                               dataBlockRequired,
@@ -5074,7 +5070,6 @@ SAggFunctionInfo aAggs[] = {{
                               top_bottom_function_setup,
                               top_function,
                               top_function_f,
-                              no_next_step,
                               top_bottom_func_finalizer,
                               top_func_merge,
                               dataBlockRequired,
@@ -5089,7 +5084,6 @@ SAggFunctionInfo aAggs[] = {{
                               top_bottom_function_setup,
                               bottom_function,
                               bottom_function_f,
-                              no_next_step,
                               top_bottom_func_finalizer,
                               bottom_func_merge,
                               dataBlockRequired,
@@ -5103,7 +5097,6 @@ SAggFunctionInfo aAggs[] = {{
                               spread_function_setup,
                               spread_function,
                               spread_function_f,
-                              no_next_step,
                               spread_function_finalizer,
                               spread_func_merge,
                               countRequired,
@@ -5117,7 +5110,6 @@ SAggFunctionInfo aAggs[] = {{
                               twa_function_setup,
                               twa_function,
                               twa_function_f,
-                              no_next_step,
                               twa_function_finalizer,
                               twa_function_copy,
                               dataBlockRequired,
@@ -5131,7 +5123,6 @@ SAggFunctionInfo aAggs[] = {{
                               leastsquares_function_setup,
                               leastsquares_function,
                               leastsquares_function_f,
-                              no_next_step,
                               leastsquares_finalizer,
                               noop1,
                               dataBlockRequired,
@@ -5145,35 +5136,32 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               date_col_output_function,
                               date_col_output_function_f,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               noDataRequired,
                           },
                           {
                               // 17
-                              "ts",
+                              "ts_dummy",
                               TSDB_FUNC_TS_DUMMY,
                               TSDB_FUNC_TS_DUMMY,
                               TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
                               function_setup,
                               noop1,
                               noop2,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               dataBlockRequired,
                           },
                           {
                               // 18
-                              "tag",
+                              "tag_dummy",
                               TSDB_FUNC_TAG_DUMMY,
                               TSDB_FUNC_TAG_DUMMY,
                               TSDB_BASE_FUNC_SO,
                               function_setup,
                               tag_function,
                               noop2,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               noDataRequired,
@@ -5187,7 +5175,6 @@ SAggFunctionInfo aAggs[] = {{
                               ts_comp_function_setup,
                               ts_comp_function,
                               ts_comp_function_f,
-                              no_next_step,
                               ts_comp_finalize,
                               copy_function,
                               dataBlockRequired,
@@ -5201,7 +5188,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               tag_function,
                               tag_function_f,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               noDataRequired,
@@ -5215,7 +5201,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               col_project_function,
                               col_project_function_f,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               dataBlockRequired,
@@ -5229,7 +5214,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               tag_project_function,
                               tag_project_function_f,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               noDataRequired,
@@ -5243,7 +5227,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               arithmetic_function,
                               arithmetic_function_f,
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               dataBlockRequired,
@@ -5257,7 +5240,6 @@ SAggFunctionInfo aAggs[] = {{
                               diff_function_setup,
                               diff_function,
                               diff_function_f,
-                              no_next_step,
                               doFinalizer,
                               noop1,
                               dataBlockRequired,
@@ -5272,7 +5254,6 @@ SAggFunctionInfo aAggs[] = {{
                               first_last_function_setup,
                               first_dist_function,
                               first_dist_function_f,
-                              no_next_step,
                               function_finalizer,
                               first_dist_func_merge,
                               firstDistFuncRequired,
@@ -5286,7 +5267,6 @@ SAggFunctionInfo aAggs[] = {{
                               first_last_function_setup,
                               last_dist_function,
                               last_dist_function_f,
-                              no_next_step,
                               function_finalizer,
                               last_dist_func_merge,
                               lastDistFuncRequired,
@@ -5300,7 +5280,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               stddev_dst_function,
                               stddev_dst_function_f,
-                              no_next_step,
                               stddev_dst_finalizer,
                               stddev_dst_merge,
                               dataBlockRequired,
@@ -5314,7 +5293,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               interp_function,
                               do_sum_f,  // todo filter handle
-                              no_next_step,
                               doFinalizer,
                               copy_function,
                               dataBlockRequired,
@@ -5328,7 +5306,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               rate_function,
                               rate_function_f,
-                              no_next_step,
                               rate_finalizer,
                               rate_func_copy,
                               dataBlockRequired,
@@ -5342,7 +5319,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               irate_function,
                               irate_function_f,
-                              no_next_step,
                               rate_finalizer,
                               rate_func_copy,
                               dataBlockRequired,
@@ -5356,7 +5332,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               rate_function,
                               rate_function_f,
-                              no_next_step,
                               sumrate_finalizer,
                               sumrate_func_merge,
                               dataBlockRequired,
@@ -5370,7 +5345,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               irate_function,
                               irate_function_f,
-                              no_next_step,
                               sumrate_finalizer,
                               sumrate_func_merge,
                               dataBlockRequired,
@@ -5384,7 +5358,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               rate_function,
                               rate_function_f,
-                              no_next_step,
                               sumrate_finalizer,
                               sumrate_func_merge,
                               dataBlockRequired,
@@ -5398,7 +5371,6 @@ SAggFunctionInfo aAggs[] = {{
                               rate_function_setup,
                               irate_function,
                               irate_function_f,
-                              no_next_step,
                               sumrate_finalizer,
                               sumrate_func_merge,
                               dataBlockRequired,
@@ -5412,7 +5384,6 @@ SAggFunctionInfo aAggs[] = {{
                               function_setup,
                               noop1,
                               noop2,
-                              no_next_step,
                               noop1,
                               noop1,
                               dataBlockRequired,
@@ -5426,7 +5397,6 @@ SAggFunctionInfo aAggs[] = {{
                                 function_setup,
                                 blockInfo_func,
                                 noop2,
-                                no_next_step,
                                 blockinfo_func_finalizer,
                                 block_func_merge,
                                 dataBlockRequired,

src/query/src/qExtbuffer.c

@@ -20,6 +20,7 @@
 #include "taosdef.h"
 #include "taosmsg.h"
 #include "tulog.h"
+#include "qExecutor.h"
 
 #define COLMODEL_GET_VAL(data, schema, allrow, rowId, colId) \
   (data + (schema)->pFields[colId].offset * (allrow) + (rowId) * (schema)->pFields[colId].field.bytes)
@@ -352,47 +353,28 @@ static FORCE_INLINE int32_t primaryKeyComparator(int64_t f1, int64_t f2, int32_t
   }
 }
 
-static FORCE_INLINE int32_t columnValueAscendingComparator(char *f1, char *f2, int32_t type, int32_t bytes) {
+static int32_t tsCompareFunc(TSKEY k1, TSKEY k2, int32_t order) {
+  if (k1 == k2) {
+    return 0;
+  }
+
+  if (order == TSDB_ORDER_DESC) {
+    return (k1 < k2)? 1:-1;
+  } else {
+    return (k1 < k2)? -1:1;
+  }
+}
+
+int32_t columnValueAscendingComparator(char *f1, char *f2, int32_t type, int32_t bytes) {
   switch (type) {
-    case TSDB_DATA_TYPE_INT: {
+    case TSDB_DATA_TYPE_INT:     DEFAULT_COMP(GET_INT32_VAL(f1), GET_INT32_VAL(f2));
-      int32_t first  = *(int32_t *) f1;
+    case TSDB_DATA_TYPE_DOUBLE:  DEFAULT_DOUBLE_COMP(GET_DOUBLE_VAL(f1), GET_DOUBLE_VAL(f2));
-      int32_t second = *(int32_t *) f2;
+    case TSDB_DATA_TYPE_FLOAT:   DEFAULT_FLOAT_COMP(GET_FLOAT_VAL(f1), GET_FLOAT_VAL(f2));
-      if (first == second) {
+    case TSDB_DATA_TYPE_BIGINT:  DEFAULT_COMP(GET_INT64_VAL(f1), GET_INT64_VAL(f2));
-        return 0;
+    case TSDB_DATA_TYPE_SMALLINT:DEFAULT_COMP(GET_INT16_VAL(f1), GET_INT16_VAL(f2));
-      }
-      return (first < second) ? -1 : 1;
-    };
-    case TSDB_DATA_TYPE_DOUBLE: {
-      DEFAULT_DOUBLE_COMP(GET_DOUBLE_VAL(f1), GET_DOUBLE_VAL(f2));
-    };
-    case TSDB_DATA_TYPE_FLOAT: {
-      DEFAULT_FLOAT_COMP(GET_FLOAT_VAL(f1), GET_FLOAT_VAL(f2));
-    };
-    case TSDB_DATA_TYPE_BIGINT: {
-      int64_t first = *(int64_t *)f1;
-      int64_t second = *(int64_t *)f2;
-      if (first == second) {
-        return 0;
-      }
-      return (first < second) ? -1 : 1;
-    };
-    case TSDB_DATA_TYPE_SMALLINT: {
-      int16_t first = *(int16_t *)f1;
-      int16_t second = *(int16_t *)f2;
-      if (first == second) {
-        return 0;
-      }
-      return (first < second) ? -1 : 1;
-    };
     case TSDB_DATA_TYPE_BOOL:
-    case TSDB_DATA_TYPE_TINYINT: {
+    case TSDB_DATA_TYPE_TINYINT: DEFAULT_COMP(GET_INT8_VAL(f1), GET_INT8_VAL(f2));
-      int8_t first = *(int8_t *)f1;
+
-      int8_t second = *(int8_t *)f2;
-      if (first == second) {
-        return 0;
-      }
-      return (first < second) ? -1 : 1;
-    };
     case TSDB_DATA_TYPE_BINARY: {
       int32_t len1 = varDataLen(f1);
       int32_t len2 = varDataLen(f2);
@@ -415,6 +397,10 @@ static FORCE_INLINE int32_t columnValueAscendingComparator(char *f1, char *f2, i
       }
       return (ret < 0) ? -1 : 1;
     };
+    case TSDB_DATA_TYPE_UTINYINT:  DEFAULT_COMP(GET_UINT8_VAL(f1), GET_UINT8_VAL(f2));
+    case TSDB_DATA_TYPE_USMALLINT: DEFAULT_COMP(GET_UINT16_VAL(f1), GET_UINT16_VAL(f2));
+    case TSDB_DATA_TYPE_UINT:      DEFAULT_COMP(GET_UINT32_VAL(f1), GET_UINT32_VAL(f2));
+    case TSDB_DATA_TYPE_UBIGINT:   DEFAULT_COMP(GET_UINT64_VAL(f1), GET_UINT64_VAL(f2));
   }
   
   return 0;
@@ -452,6 +438,35 @@ int32_t compare_a(tOrderDescriptor *pDescriptor, int32_t numOfRows1, int32_t s1,
   return 0;
 }
 
+int32_t compare_aRv(SSDataBlock* pBlock, SArray* colIndex, int32_t numOfCols, int32_t rowIndex, char** buffer, int32_t order) {
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColIndex* pColIndex = taosArrayGet(colIndex, i);
+    int32_t index = pColIndex->colIndex;
+
+    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, index);
+    assert(pColIndex->colId == pColInfo->info.colId);
+
+    char* data = pColInfo->pData + rowIndex * pColInfo->info.bytes;
+    if (pColInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+      int32_t ret = tsCompareFunc(GET_INT64_VAL(data), GET_INT64_VAL(buffer[i]), order);
+      if (ret == 0) {
+        continue; // The timestamps are identical
+      } else {
+        return ret;
+      }
+    } else {
+      int32_t ret = columnValueAscendingComparator(data, buffer[i], pColInfo->info.type, pColInfo->info.bytes);
+      if (ret == 0) {
+        continue;
+      } else {
+        return ret;
+      }
+    }
+  }
+
+  return 0;
+}
+
 int32_t compare_d(tOrderDescriptor *pDescriptor, int32_t numOfRows1, int32_t s1, char *data1, int32_t numOfRows2,
                   int32_t s2, char *data2) {
   assert(numOfRows1 == numOfRows2);

src/query/src/qFill.c

@@ -31,7 +31,7 @@
 static void setTagsValue(SFillInfo* pFillInfo, void** data, int32_t genRows) {
   for(int32_t j = 0; j < pFillInfo->numOfCols; ++j) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[j];
-    if (TSDB_COL_IS_NORMAL_COL(pCol->flag)) {
+    if (TSDB_COL_IS_NORMAL_COL(pCol->flag) || TSDB_COL_IS_UD_COL(pCol->flag)) {
       continue;
     }
 
@@ -126,10 +126,10 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
     } else {
       setNullValueForRow(pFillInfo, data, pFillInfo->numOfCols, index);
     }
-  } else { /* fill the default value */
+  } else { // fill the default value */
     for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-      if (TSDB_COL_IS_TAG(pCol->flag)) {
+      if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {
         continue;
       }
 
@@ -210,7 +210,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
       // assign rows to dst buffer
       for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-        if (TSDB_COL_IS_TAG(pCol->flag)) {
+        if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {
           continue;
         }
 
@@ -275,13 +275,16 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, void** output, int64_t r
 // there are no duplicated tags in the SFillTagColInfo list
 static int32_t setTagColumnInfo(SFillInfo* pFillInfo, int32_t numOfCols, int32_t capacity) {
   int32_t rowsize = 0;
+  int32_t numOfTags = 0;
 
   int32_t k = 0;
   for (int32_t i = 0; i < numOfCols; ++i) {
     SFillColInfo* pColInfo = &pFillInfo->pFillCol[i];
     pFillInfo->pData[i] = NULL;
 
-    if (TSDB_COL_IS_TAG(pColInfo->flag)) {
+    if (TSDB_COL_IS_TAG(pColInfo->flag) || pColInfo->col.type == TSDB_DATA_TYPE_BINARY) {
+      numOfTags += 1;
+
       bool exists = false;
       int32_t index = -1;
       for (int32_t j = 0; j < k; ++j) {
@@ -310,6 +313,8 @@ static int32_t setTagColumnInfo(SFillInfo* pFillInfo, int32_t numOfCols, int32_t
     rowsize += pColInfo->col.bytes;
   }
 
+  pFillInfo->numOfTags = numOfTags;
+
   assert(k <= pFillInfo->numOfTags);
   return rowsize;
 }
@@ -347,12 +352,13 @@ SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int3
   pFillInfo->interval.slidingUnit  = slidingUnit;
 
   pFillInfo->pData = malloc(POINTER_BYTES * numOfCols);
-  if (numOfTags > 0) {
+
-    pFillInfo->pTags = calloc(pFillInfo->numOfTags, sizeof(SFillTagColInfo));
+//  if (numOfTags > 0) {
-    for (int32_t i = 0; i < numOfTags; ++i) {
+    pFillInfo->pTags = calloc(numOfCols, sizeof(SFillTagColInfo));
+    for (int32_t i = 0; i < numOfCols; ++i) {
       pFillInfo->pTags[i].col.colId = -2;  // TODO
     }
-  }
+//  }
 
   pFillInfo->rowSize = setTagColumnInfo(pFillInfo, pFillInfo->numOfCols, pFillInfo->alloc);
   assert(pFillInfo->rowSize > 0);
@@ -367,6 +373,7 @@ SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int3
 void taosResetFillInfo(SFillInfo* pFillInfo, TSKEY startTimestamp) {
   pFillInfo->start        = startTimestamp;
   pFillInfo->currentKey   = startTimestamp;
+  pFillInfo->end          = startTimestamp;
   pFillInfo->index        = -1;
   pFillInfo->numOfRows    = 0;
   pFillInfo->numOfCurrent = 0;
@@ -425,6 +432,8 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
 void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput) {
   for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
+    SFillColInfo* pCol = &pFillInfo->pFillCol[i];
+
     SColumnInfoData* pColData = taosArrayGet(pInput->pDataBlock, i);
 //    pFillInfo->pData[i] = pColData->pData;
     if (pInput->info.rows > pFillInfo->alloc) {
@@ -436,6 +445,12 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
     }
 
     memcpy(pFillInfo->pData[i], pColData->pData, pColData->info.bytes * pInput->info.rows);
+
+    if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
+      SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
+      assert (pTag->col.colId == pCol->col.colId);
+      memcpy(pTag->tagVal, pColData->pData, pCol->col.bytes);  // TODO not memcpy??
+    }
   }
 }
 
@@ -456,7 +471,7 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage*
 
     memcpy(pFillInfo->pData[i], data, (size_t)(pCol->col.bytes * pInput->num));
 
-    if (TSDB_COL_IS_TAG(pCol->flag)) {  // copy the tag value to tag value buffer
+    if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
       SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
       assert (pTag->col.colId == pCol->col.colId);
       memcpy(pTag->tagVal, data, pCol->col.bytes);  // TODO not memcpy??
@@ -465,7 +480,17 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage*
 }
 
 bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
-  return taosNumOfRemainRows(pFillInfo) > 0;
+  int32_t remain = taosNumOfRemainRows(pFillInfo);
+  if (remain > 0) {
+    return true;
+  }
+
+  if (pFillInfo->numOfTotal > 0 && (((pFillInfo->end > pFillInfo->start) && FILL_IS_ASC_FILL(pFillInfo)) ||
+                                    (pFillInfo->end < pFillInfo->start && !FILL_IS_ASC_FILL(pFillInfo)))) {
+    return getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, 4096) > 0;
+  }
+
+  return false;
 }
 
 int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t maxNumOfRows) {

src/query/src/qPlan.c

@@ -0,0 +1,195 @@
+#include "os.h"
+#include "tsclient.h"
+#include "qUtil.h"
+#include "texpr.h"
+
+#define QNODE_PROJECT    1
+#define QNODE_FILTER     2
+#define QNODE_RELATION   3
+#define QNODE_AGGREGATE  4
+#define QNODE_GROUPBY    5
+#define QNODE_LIMIT      6
+#define QNODE_JOIN       7
+#define QNODE_DIST       8
+#define QNODE_SORT       9
+#define QNODE_UNIONALL   10
+#define QNODE_TIMEWINDOW 11
+
+typedef struct SQueryNode {
+  int32_t    type;         // the type of logic node
+  char      *name;         // the name of logic node
+
+  SSchema   *pSchema;      // the schema of the input SSDatablock
+  int32_t    numOfCols;    // number of input columns
+  SExprInfo *pExpr;        // the query functions or sql aggregations
+  int32_t    numOfOutput;  // number of result columns, which is also the number of pExprs
+
+  // previous operator to generated result for current node to process
+  // in case of join, multiple prev nodes exist.
+  struct SQueryNode* prevNode;
+  struct SQueryNode* nextNode;
+} SQueryNode;
+
+// TODO create the query plan
+SQueryNode* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
+  return NULL;
+}
+
+char* queryPlanToString() {
+  return NULL;
+}
+
+SQueryNode* queryPlanFromString() {
+  return NULL;
+}
+
+SArray* createTableScanPlan(SQueryAttr* pQueryAttr) {
+  SArray* plan = taosArrayInit(4, sizeof(int32_t));
+
+  int32_t op = 0;
+  if (onlyQueryTags(pQueryAttr)) {
+//    op = OP_TagScan;
+  } else {
+    if (pQueryAttr->queryBlockDist) {
+      op = OP_TableBlockInfoScan;
+    } else if (pQueryAttr->tsCompQuery || pQueryAttr->pointInterpQuery) {
+      op = OP_TableSeqScan;
+    } else if (pQueryAttr->needReverseScan) {
+      op = OP_DataBlocksOptScan;
+    } else {
+      op = OP_TableScan;
+    }
+
+    taosArrayPush(plan, &op);
+  }
+
+  return plan;
+}
+
+SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
+  SArray* plan = taosArrayInit(4, sizeof(int32_t));
+  int32_t op = 0;
+
+  if (onlyQueryTags(pQueryAttr)) {  // do nothing for tags query
+    op = OP_TagScan;
+    taosArrayPush(plan, &op);
+    if (pQueryAttr->distinctTag) {
+      op = OP_Distinct;
+      taosArrayPush(plan, &op);
+    }
+  } else if (pQueryAttr->interval.interval > 0) {
+    if (pQueryAttr->stableQuery) {
+      op = OP_MultiTableTimeInterval;
+      taosArrayPush(plan, &op);
+    } else {
+      op = OP_TimeWindow;
+      taosArrayPush(plan, &op);
+
+      if (pQueryAttr->pExpr2 != NULL) {
+        op = OP_Arithmetic;
+        taosArrayPush(plan, &op);
+      }
+
+      if (pQueryAttr->fillType != TSDB_FILL_NONE && (!pQueryAttr->pointInterpQuery)) {
+        op = OP_Fill;
+        taosArrayPush(plan, &op);
+      }
+    }
+
+  } else if (pQueryAttr->groupbyColumn) {
+    op = OP_Groupby;
+    taosArrayPush(plan, &op);
+
+    if (!pQueryAttr->stableQuery && pQueryAttr->havingNum > 0) {
+      op = OP_Filter;
+      taosArrayPush(plan, &op);
+    }
+
+    if (pQueryAttr->pExpr2 != NULL) {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
+  } else if (pQueryAttr->sw.gap > 0) {
+    op = OP_SessionWindow;
+    taosArrayPush(plan, &op);
+
+    if (pQueryAttr->pExpr2 != NULL) {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
+  } else if (pQueryAttr->simpleAgg) {
+    if (pQueryAttr->stableQuery && !pQueryAttr->tsCompQuery) {
+      op = OP_MultiTableAggregate;
+    } else {
+      op = OP_Aggregate;
+    }
+
+    taosArrayPush(plan, &op);
+
+    if (!pQueryAttr->stableQuery && pQueryAttr->havingNum > 0) {
+      op = OP_Filter;
+      taosArrayPush(plan, &op);
+    }
+
+    if (pQueryAttr->pExpr2 != NULL && !pQueryAttr->stableQuery) {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
+  } else {  // diff/add/multiply/subtract/division
+    op = OP_Arithmetic;
+    taosArrayPush(plan, &op);
+  }
+
+  if (pQueryAttr->limit.limit > 0 || pQueryAttr->limit.offset > 0) {
+    op = OP_Limit;
+    taosArrayPush(plan, &op);
+  }
+
+  return plan;
+}
+
+SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr) {
+  SArray* plan = taosArrayInit(4, sizeof(int32_t));
+
+  if (!pQueryAttr->stableQuery) {
+    return plan;
+  }
+
+  int32_t op = OP_MultiwayMergeSort;
+  taosArrayPush(plan, &op);
+
+  if (pQueryAttr->distinctTag) {
+    op = OP_Distinct;
+    taosArrayPush(plan, &op);
+  }
+
+  if (pQueryAttr->simpleAgg || (pQueryAttr->interval.interval > 0 || pQueryAttr->sw.gap > 0)) {
+    op = OP_GlobalAggregate;
+    taosArrayPush(plan, &op);
+
+    if (pQueryAttr->havingNum > 0) {
+      op = OP_Filter;
+      taosArrayPush(plan, &op);
+    }
+
+    if (pQueryAttr->pExpr2 != NULL) {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
+  }
+
+  // fill operator
+  if (pQueryAttr->fillType != TSDB_FILL_NONE && (!pQueryAttr->pointInterpQuery)) {
+    op = OP_Fill;
+    taosArrayPush(plan, &op);
+  }
+
+  // limit/offset operator
+  if (pQueryAttr->limit.limit > 0 || pQueryAttr->limit.offset > 0 ||
+      pQueryAttr->slimit.limit > 0 || pQueryAttr->slimit.offset > 0) {
+    op = OP_SLimit;
+    taosArrayPush(plan, &op);
+  }
+
+  return plan;
+}

src/query/src/qResultbuf.c

@@ -43,7 +43,7 @@ int32_t createDiskbasedResultBuffer(SDiskbasedResultBuf** pResultBuf, int32_t pa
 
   pResBuf->emptyDummyIdList = taosArrayInit(1, sizeof(int32_t));
 
-  qDebug("QInfo:%"PRIu64" create resBuf for output, page size:%d, inmem buf pages:%d, file:%s", qId, pResBuf->pageSize,
+  qDebug("QInfo:0x%"PRIx64" create resBuf for output, page size:%d, inmem buf pages:%d, file:%s", qId, pResBuf->pageSize,
          pResBuf->inMemPages, pResBuf->path);
 
   return TSDB_CODE_SUCCESS;
@@ -410,13 +410,13 @@ void destroyResultBuf(SDiskbasedResultBuf* pResultBuf) {
   }
 
   if (pResultBuf->file != NULL) {
-    qDebug("QInfo:%"PRIu64" res output buffer closed, total:%.2f Kb, inmem size:%.2f Kb, file size:%.2f Kb",
+    qDebug("QInfo:0x%"PRIx64" res output buffer closed, total:%.2f Kb, inmem size:%.2f Kb, file size:%.2f Kb",
         pResultBuf->qId, pResultBuf->totalBufSize/1024.0, listNEles(pResultBuf->lruList) * pResultBuf->pageSize / 1024.0,
         pResultBuf->fileSize/1024.0);
 
     fclose(pResultBuf->file);
   } else {
-    qDebug("QInfo:%"PRIu64" res output buffer closed, total:%.2f Kb, no file created", pResultBuf->qId,
+    qDebug("QInfo:0x%"PRIx64" res output buffer closed, total:%.2f Kb, no file created", pResultBuf->qId,
            pResultBuf->totalBufSize/1024.0);
   }
 

src/query/src/qSqlParser.c

@@ -144,12 +144,15 @@ tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType) {
     pSqlExpr->value.nType = TSDB_DATA_TYPE_BIGINT;
     pSqlExpr->tokenId = TK_TIMESTAMP;  // TK_TIMESTAMP used to denote the time value is in microsecond
     pSqlExpr->type    = SQL_NODE_VALUE;
+    pSqlExpr->flags  |= 1 << EXPR_FLAG_US_TIMESTAMP;
   } else if (optrType == TK_VARIABLE) {
     int32_t ret = parseAbsoluteDuration(pToken->z, pToken->n, &pSqlExpr->value.i64);
     if (ret != TSDB_CODE_SUCCESS) {
       terrno = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
     }
 
+    pSqlExpr->flags  |= 1 << EXPR_FLAG_US_TIMESTAMP;
+    pSqlExpr->flags  |= 1 << EXPR_FLAG_TIMESTAMP_VAR;
     pSqlExpr->value.nType = TSDB_DATA_TYPE_BIGINT;
     pSqlExpr->tokenId = TK_TIMESTAMP;
     pSqlExpr->type    = SQL_NODE_VALUE;
@@ -217,6 +220,15 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
       pExpr->value.nType = TSDB_DATA_TYPE_BIGINT;
       pExpr->tokenId = pLeft->tokenId;
       pExpr->type    = SQL_NODE_VALUE;
+      pExpr->flags   = pLeft->flags | pRight->flags;
+
+      if ((pLeft->flags & (1 << EXPR_FLAG_TIMESTAMP_VAR)) && (pRight->flags & (1 << EXPR_FLAG_TIMESTAMP_VAR))) {
+        pExpr->flags |= 1 << EXPR_FLAG_TS_ERROR;
+      } else {
+        pExpr->flags &= ~(1 << EXPR_FLAG_TIMESTAMP_VAR);
+        pExpr->flags &= ~(1 << EXPR_FLAG_TS_ERROR);
+      }
+
 
       switch (optrType) {
         case TK_PLUS: {
@@ -245,7 +257,6 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
 
       tSqlExprDestroy(pLeft);
       tSqlExprDestroy(pRight);
-
     } else if ((pLeft->tokenId == TK_FLOAT && pRight->tokenId == TK_INTEGER) ||
                (pLeft->tokenId == TK_INTEGER && pRight->tokenId == TK_FLOAT) ||
                (pLeft->tokenId == TK_FLOAT && pRight->tokenId == TK_FLOAT)) {
@@ -319,7 +330,7 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   if ((left == NULL && right) || (left && right == NULL)) {
     return 1;
   }
-  
+
   if (left->type != right->type) {
     return 1;
   }
@@ -332,11 +343,11 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
     return 1;
   }
 
-  if ((left->pLeft && right->pLeft == NULL) 
+  if ((left->pLeft && right->pLeft == NULL)
     || (left->pLeft == NULL && right->pLeft)
-    || (left->pRight && right->pRight == NULL) 
+    || (left->pRight && right->pRight == NULL)
     || (left->pRight == NULL && right->pRight)
-    || (left->pParam && right->pParam == NULL) 
+    || (left->pParam && right->pParam == NULL)
     || (left->pParam == NULL && right->pParam)) {
     return 1;
   }
@@ -349,19 +360,18 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
     return 1;
   }
 
-
   if (right->pParam && left->pParam) {
     size_t size = taosArrayGetSize(right->pParam);
     if (left->pParam && taosArrayGetSize(left->pParam) != size) {
       return 1;
     }
 
-    for (int32_t i = 0; i < size; i++) {      
+    for (int32_t i = 0; i < size; i++) {
       tSqlExprItem* pLeftElem = taosArrayGet(left->pParam, i);
       tSqlExpr* pSubLeft = pLeftElem->pNode;
-      tSqlExprItem* pRightElem = taosArrayGet(left->pParam, i);
+      tSqlExprItem* pRightElem = taosArrayGet(right->pParam, i);
       tSqlExpr* pSubRight = pRightElem->pNode;
-    
+
       if (tSqlExprCompare(pSubLeft, pSubRight)) {
         return 1;
       }
@@ -523,13 +533,13 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
   return pList;
 }
 
-SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias) {
+SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName, SStrToken* pAlias) {
-  if (pFromInfo == NULL) {
+  if (pRelationInfo == NULL) {
-    pFromInfo = calloc(1, sizeof(SFromInfo));
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
-    pFromInfo->tableList = taosArrayInit(4, sizeof(STableNamePair));
+    pRelationInfo->list = taosArrayInit(4, sizeof(STableNamePair));
   }
 
-  pFromInfo->type = SQL_NODE_FROM_NAMELIST;
+  pRelationInfo->type = SQL_NODE_FROM_TABLELIST;
   STableNamePair p = {.name = *pName};
   if (pAlias != NULL) {
     p.aliasName = *pAlias;
@@ -537,34 +547,39 @@ SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* p
     TPARSER_SET_NONE_TOKEN(p.aliasName);
   }
 
-  taosArrayPush(pFromInfo->tableList, &p);
+  taosArrayPush(pRelationInfo->list, &p);
-
+  return pRelationInfo;
-  return pFromInfo;
 }
 
-SFromInfo *setSubquery(SFromInfo* pFromInfo, SQuerySqlNode* pSqlNode) {
+SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList) {
-  if (pFromInfo == NULL) {
+  if (pRelationInfo == NULL) {
-    pFromInfo = calloc(1, sizeof(SFromInfo));
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
   }
 
-  pFromInfo->type = SQL_NODE_FROM_SUBQUERY;
+  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
-  pFromInfo->pNode->pClause[pFromInfo->pNode->numOfClause - 1] = pSqlNode;
+  taosArrayPush(pRelationInfo->list, &pList);
 
-  return pFromInfo;
+  return pRelationInfo;
 }
 
-void* destroyFromInfo(SFromInfo* pFromInfo) {
+void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
-  if (pFromInfo == NULL) {
+  if (pRelationInfo == NULL) {
     return NULL;
   }
 
-  if (pFromInfo->type == SQL_NODE_FROM_NAMELIST) {
+  if (pRelationInfo->type == SQL_NODE_FROM_TABLELIST) {
-    taosArrayDestroy(pFromInfo->tableList);
+    taosArrayDestroy(pRelationInfo->list);
   } else {
-    destroyAllSelectClause(pFromInfo->pNode);
+    size_t size = taosArrayGetSize(pRelationInfo->list);
+    for(int32_t i = 0; i < size; ++i) {
+      SArray* pa = taosArrayGetP(pRelationInfo->list, 0);
+      destroyAllSqlNode(pa);
+    }
+    taosArrayDestroy(pRelationInfo->list);
   }
 
-  tfree(pFromInfo);
+  tfree(pRelationInfo);
   return NULL;
 }
 
@@ -708,19 +723,19 @@ void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
 /*
  * extract the select info out of sql string
  */
-SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SFromInfo *pFrom, tSqlExpr *pWhere,
+SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                                 SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
                                 SLimitVal *psLimit, tSqlExpr *pHaving) {
-  assert(pSelectList != NULL);
+  assert(pSelNodeList != NULL);
 
-  SQuerySqlNode *pSqlNode = calloc(1, sizeof(SQuerySqlNode));
+  SSqlNode *pSqlNode = calloc(1, sizeof(SSqlNode));
 
   // all later sql string are belonged to the stream sql
   pSqlNode->sqlstr   = *pSelectToken;
   pSqlNode->sqlstr.n = (uint32_t)strlen(pSqlNode->sqlstr.z);
 
-  pSqlNode->pSelectList = pSelectList;
+  pSqlNode->pSelNodeList = pSelNodeList;
   pSqlNode->from        = pFrom;
   pSqlNode->pGroupby    = pGroupby;
   pSqlNode->pSortOrder  = pSortOrder;
@@ -778,49 +793,47 @@ void freeCreateTableInfo(void* p) {
   tfree(pInfo->tagdata.data);
 }
 
-void destroyQuerySqlNode(SQuerySqlNode *pQuerySql) {
+void destroySqlNode(SSqlNode *pSqlNode) {
-  if (pQuerySql == NULL) {
+  if (pSqlNode == NULL) {
     return;
   }
 
-  tSqlExprListDestroy(pQuerySql->pSelectList);
+  tSqlExprListDestroy(pSqlNode->pSelNodeList);
+  pSqlNode->pSelNodeList = NULL;
+
+  tSqlExprDestroy(pSqlNode->pWhere);
+  pSqlNode->pWhere = NULL;
   
-  pQuerySql->pSelectList = NULL;
+  taosArrayDestroyEx(pSqlNode->pSortOrder, freeVariant);
+  pSqlNode->pSortOrder = NULL;
 
-  tSqlExprDestroy(pQuerySql->pWhere);
+  taosArrayDestroyEx(pSqlNode->pGroupby, freeVariant);
-  pQuerySql->pWhere = NULL;
+  pSqlNode->pGroupby = NULL;
 
-  tSqlExprDestroy(pQuerySql->pHaving);
+  pSqlNode->from = destroyRelationInfo(pSqlNode->from);
-  pQuerySql->pHaving = NULL;
-  
-  taosArrayDestroyEx(pQuerySql->pSortOrder, freeVariant);
-  pQuerySql->pSortOrder = NULL;
 
-  taosArrayDestroyEx(pQuerySql->pGroupby, freeVariant);
+  taosArrayDestroyEx(pSqlNode->fillType, freeVariant);
-  pQuerySql->pGroupby = NULL;
+  pSqlNode->fillType = NULL;
 
-  pQuerySql->from = destroyFromInfo(pQuerySql->from);
+  tSqlExprDestroy(pSqlNode->pHaving);
-
+  free(pSqlNode);
-  taosArrayDestroyEx(pQuerySql->fillType, freeVariant);
-  pQuerySql->fillType = NULL;
-
-  free(pQuerySql);
 }
 
-void destroyAllSelectClause(SSubclauseInfo *pClause) {
+void destroyAllSqlNode(SArray *pList) {
-  if (pClause == NULL || pClause->numOfClause == 0) {
+  if (pList == NULL) {
     return;
   }
 
-  for(int32_t i = 0; i < pClause->numOfClause; ++i) {
+  size_t size = taosArrayGetSize(pList);
-    SQuerySqlNode *pQuerySql = pClause->pClause[i];
+  for(int32_t i = 0; i < size; ++i) {
-    destroyQuerySqlNode(pQuerySql);
+    SSqlNode *pNode = taosArrayGetP(pList, i);
+    destroySqlNode(pNode);
   }
-  
+
-  tfree(pClause->pClause);
+  taosArrayDestroy(pList);
 }
 
-SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type) {
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SSqlNode *pSelect, int32_t type) {
   SCreateTableSql *pCreate = calloc(1, sizeof(SCreateTableSql));
 
   switch (type) {
@@ -888,7 +901,7 @@ SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray
 }
 
 void* destroyCreateTableSql(SCreateTableSql* pCreate) {
-  destroyQuerySqlNode(pCreate->pSelect);
+  destroySqlNode(pCreate->pSelect);
 
   taosArrayDestroy(pCreate->colInfo.pColumns);
   taosArrayDestroy(pCreate->colInfo.pTagColumns);
@@ -903,7 +916,7 @@ void SqlInfoDestroy(SSqlInfo *pInfo) {
   if (pInfo == NULL) return;
 
   if (pInfo->type == TSDB_SQL_SELECT) {
-    destroyAllSelectClause(&pInfo->subclauseInfo);
+    destroyAllSqlNode(pInfo->list);
   } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
     pInfo->pCreateTableInfo = destroyCreateTableSql(pInfo->pCreateTableInfo);
   } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
@@ -924,31 +937,20 @@ void SqlInfoDestroy(SSqlInfo *pInfo) {
   }
 }
 
-SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
+SArray* setSubclause(SArray* pList, void *pSqlNode) {
-  if (pSubclause == NULL) {
+  if (pList == NULL) {
-    pSubclause = calloc(1, sizeof(SSubclauseInfo));
+    pList = taosArrayInit(1, POINTER_BYTES);
   }
   
-  int32_t newSize = pSubclause->numOfClause + 1;
+  taosArrayPush(pList, &pSqlNode);
-  char* tmp = realloc(pSubclause->pClause, newSize * POINTER_BYTES);
+  return pList;
-  if (tmp == NULL) {
-    return pSubclause;
-  }
-  
-  pSubclause->pClause = (SQuerySqlNode**) tmp;
-  
-  pSubclause->pClause[newSize - 1] = pSqlExprInfo;
-  pSubclause->numOfClause++;
-  
-  return pSubclause;
 }
 
 SSqlInfo* setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type) {
   pInfo->type = type;
   
   if (type == TSDB_SQL_SELECT) {
-    pInfo->subclauseInfo = *(SSubclauseInfo*) pSqlExprInfo;
+    pInfo->list = (SArray*) pSqlExprInfo;
-    free(pSqlExprInfo);
   } else {
     pInfo->pCreateTableInfo = pSqlExprInfo;
   }
@@ -960,16 +962,9 @@ SSqlInfo* setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName,
   return pInfo;
 }
 
-SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause) {
+SArray* appendSelectClause(SArray *pList, void *pSubclause) {
-  char* tmp = realloc(pQueryInfo->pClause, (pQueryInfo->numOfClause + 1) * POINTER_BYTES);
+  taosArrayPush(pList, &pSubclause);
-  if (tmp == NULL) {  // out of memory
+  return pList;
-    return pQueryInfo;
-  }
-  
-  pQueryInfo->pClause = (SQuerySqlNode**) tmp;
-  pQueryInfo->pClause[pQueryInfo->numOfClause++] = pSubclause;
-  
-  return pQueryInfo;
 }
 
 void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists) {

src/query/src/qUtil.c

@@ -30,11 +30,11 @@ typedef struct SCompSupporter {
   int32_t           order;
 } SCompSupporter;
 
-int32_t getOutputInterResultBufSize(SQuery* pQuery) {
+int32_t getOutputInterResultBufSize(SQueryAttr* pQueryAttr) {
   int32_t size = 0;
 
-  for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
+  for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
-    size += pQuery->pExpr1[i].interBytes;
+    size += pQueryAttr->pExpr1[i].base.interBytes;
   }
 
   assert(size >= 0);
@@ -136,11 +136,11 @@ void clearResultRow(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pResultRow, int16
     tFilePage *page = getResBufPage(pRuntimeEnv->pResultBuf, pResultRow->pageId);
 
     int16_t offset = 0;
-    for (int32_t i = 0; i < pRuntimeEnv->pQuery->numOfOutput; ++i) {
+    for (int32_t i = 0; i < pRuntimeEnv->pQueryAttr->numOfOutput; ++i) {
       SResultRowCellInfo *pResultInfo = &pResultRow->pCellInfo[i];
 
-      int16_t size = pRuntimeEnv->pQuery->pExpr1[i].bytes;
+      int16_t size = pRuntimeEnv->pQueryAttr->pExpr1[i].base.resType;
-      char * s = getPosInResultPage(pRuntimeEnv, page, pResultRow->offset, offset, size);
+      char * s = getPosInResultPage(pRuntimeEnv->pQueryAttr, page, pResultRow->offset, offset);
       memset(s, 0, size);
 
       offset += size;
@@ -164,8 +164,8 @@ SResultRowCellInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t
 }
 
 size_t getResultRowSize(SQueryRuntimeEnv* pRuntimeEnv) {
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
-  return (pQuery->numOfOutput * sizeof(SResultRowCellInfo)) + pQuery->interBufSize + sizeof(SResultRow);
+  return (pQueryAttr->numOfOutput * sizeof(SResultRowCellInfo)) + pQueryAttr->interBufSize + sizeof(SResultRow);
 }
 
 SResultRowPool* initResultRowPool(size_t size) {
@@ -382,10 +382,10 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo) {
 }
 
 static int64_t getNumOfResultWindowRes(SQueryRuntimeEnv* pRuntimeEnv, SResultRow *pResultRow, int32_t* rowCellInfoOffset) {
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
 
-  for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {
+  for (int32_t j = 0; j < pQueryAttr->numOfOutput; ++j) {
-    int32_t functionId = pQuery->pExpr1[j].base.functionId;
+    int32_t functionId = pQueryAttr->pExpr1[j].base.functionId;
 
     /*
      * ts, tag, tagprj function can not decide the output number of current query
@@ -448,7 +448,7 @@ static int32_t tableResultComparFn(const void *pLeft, const void *pRight, void *
 
 static int32_t mergeIntoGroupResultImpl(SQueryRuntimeEnv *pRuntimeEnv, SGroupResInfo* pGroupResInfo, SArray *pTableList,
     int32_t* rowCellInfoOffset) {
-  bool ascQuery = QUERY_IS_ASC_QUERY(pRuntimeEnv->pQuery);
+  bool ascQuery = QUERY_IS_ASC_QUERY(pRuntimeEnv->pQueryAttr);
 
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -484,7 +484,7 @@ static int32_t mergeIntoGroupResultImpl(SQueryRuntimeEnv *pRuntimeEnv, SGroupRes
     goto _end;
   }
 
-  SCompSupporter cs = {pTableQueryInfoList, posList, pRuntimeEnv->pQuery->order.order};
+  SCompSupporter cs = {pTableQueryInfoList, posList, pRuntimeEnv->pQueryAttr->order.order};
 
   int32_t ret = tLoserTreeCreate(&pTree, numOfTables, &cs, tableResultComparFn);
   if (ret != TSDB_CODE_SUCCESS) {

src/query/src/queryMain.c

@@ -14,7 +14,6 @@
  */
 
 #include "os.h"
-#include "qFill.h"
 #include "taosmsg.h"
 #include "tcache.h"
 #include "tglobal.h"
@@ -23,13 +22,11 @@
 #include "hash.h"
 #include "texpr.h"
 #include "qExecutor.h"
-#include "qResultbuf.h"
 #include "qUtil.h"
 #include "query.h"
 #include "queryLog.h"
 #include "tlosertree.h"
 #include "ttype.h"
-#include "tcompare.h"
 
 typedef struct SQueryMgmt {
   pthread_mutex_t lock;
@@ -58,10 +55,13 @@ void freeParam(SQueryParam *param) {
   tfree(param->tagCond);
   tfree(param->tbnameCond);
   tfree(param->pTableIdList);
-  tfree(param->pExprMsg);
+  taosArrayDestroy(param->pOperator);
-  tfree(param->pSecExprMsg);
   tfree(param->pExprs);
   tfree(param->pSecExprs);
+
+  tfree(param->pExpr);
+  tfree(param->pSecExpr);
+
   tfree(param->pGroupColIndex);
   tfree(param->pTagColumnInfo);
   tfree(param->pGroupbyExpr);
@@ -91,12 +91,14 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
     goto _over;
   }
 
-  if ((code = createQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->numOfOutput, &param.pExprs, param.pExprMsg, param.pTagColumnInfo, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
+  SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
+  if ((code = createQueryFunc(&info, pQueryMsg->numOfOutput, &param.pExprs, param.pExpr, param.pTagColumnInfo,
+                              pQueryMsg->queryType, pQueryMsg, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
     goto _over;
   }
 
-  if (param.pSecExprMsg != NULL) {
+  if (param.pSecExpr != NULL) {
-    if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExprMsg, param.pExprs, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
+    if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExpr, param.pExprs, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
       goto _over;
     }
   }
@@ -158,7 +160,9 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
     goto _over;
   }
 
-  (*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo, param.pTagColumnInfo, isSTableQuery, param.sql, qId, param.pUdfInfo);
+  assert(pQueryMsg->stableQuery == isSTableQuery);
+  (*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo,
+                              param.pTagColumnInfo, vgId, param.sql, qId, param.pUdfInfo);
 
   if ((*pQInfo) == NULL) {
     code = TSDB_CODE_QRY_OUT_OF_MEMORY;
@@ -172,7 +176,7 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
   param.pTagColumnInfo = NULL;
   param.pUdfInfo = NULL;
 
-  code = initQInfo(pQueryMsg, tsdb, vgId, *pQInfo, &param, isSTableQuery);
+  code = initQInfo(&pQueryMsg->tsBuf, tsdb, NULL, *pQInfo, &param, (char*)pQueryMsg, pQueryMsg->prevResultLen, NULL);
 
   _over:
   if (param.pGroupbyExpr != NULL) {
@@ -187,8 +191,8 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
   freeParam(&param);
 
   for (int32_t i = 0; i < pQueryMsg->numOfCols; i++) {
-    SColumnInfo* column = pQueryMsg->colList + i;
+    SColumnInfo* column = pQueryMsg->tableCols + i;
-    freeColumnFilterInfo(column->filters, column->numOfFilters);
+    freeColumnFilterInfo(column->flist.filterInfo, column->flist.numOfFilters);
   }
 
   //pQInfo already freed in initQInfo, but *pQInfo may not pointer to null;
@@ -208,23 +212,22 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
 
   int64_t curOwner = 0;
   if ((curOwner = atomic_val_compare_exchange_64(&pQInfo->owner, 0, threadId)) != 0) {
-    qError("QInfo:%"PRIu64"-%p qhandle is now executed by thread:%p", pQInfo->qId, pQInfo, (void*) curOwner);
+    qError("QInfo:0x%"PRIx64"-%p qhandle is now executed by thread:%p", pQInfo->qId, pQInfo, (void*) curOwner);
     pQInfo->code = TSDB_CODE_QRY_IN_EXEC;
     return false;
   }
 
-
   *qId = pQInfo->qId;
   pQInfo->startExecTs = taosGetTimestampSec();
 
   if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:%"PRIu64" it is already killed, abort", pQInfo->qId);
+    qDebug("QInfo:0x%"PRIx64" it is already killed, abort", pQInfo->qId);
     return doBuildResCheck(pQInfo);
   }
 
   SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
   if (pRuntimeEnv->tableqinfoGroupInfo.numOfTables == 0) {
-    qDebug("QInfo:%"PRIu64" no table exists for query, abort", pQInfo->qId);
+    qDebug("QInfo:0x%"PRIx64" no table exists for query, abort", pQInfo->qId);
     setQueryStatus(pRuntimeEnv, QUERY_COMPLETED);
     return doBuildResCheck(pQInfo);
   }
@@ -233,21 +236,22 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
   int32_t ret = setjmp(pQInfo->runtimeEnv.env);
   if (ret != TSDB_CODE_SUCCESS) {
     pQInfo->code = ret;
-    qDebug("QInfo:%"PRIu64" query abort due to error/cancel occurs, code:%s", pQInfo->qId, tstrerror(pQInfo->code));
+    qDebug("QInfo:0x%"PRIx64" query abort due to error/cancel occurs, code:%s", pQInfo->qId, tstrerror(pQInfo->code));
     return doBuildResCheck(pQInfo);
   }
 
-  qDebug("QInfo:%"PRIu64" query task is launched", pQInfo->qId);
+  qDebug("QInfo:0x%"PRIx64" query task is launched", pQInfo->qId);
 
-  pRuntimeEnv->outputBuf = pRuntimeEnv->proot->exec(pRuntimeEnv->proot);
+  bool newgroup = false;
+  pRuntimeEnv->outputBuf = pRuntimeEnv->proot->exec(pRuntimeEnv->proot, &newgroup);
 
   if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:%"PRIu64" query is killed", pQInfo->qId);
+    qDebug("QInfo:0x%"PRIx64" query is killed", pQInfo->qId);
   } else if (GET_NUM_OF_RESULTS(pRuntimeEnv) == 0) {
-    qDebug("QInfo:%"PRIu64" over, %u tables queried, %"PRId64" rows are returned", pQInfo->qId, pRuntimeEnv->tableqinfoGroupInfo.numOfTables,
+    qDebug("QInfo:0x%"PRIx64" over, %u tables queried, %"PRId64" rows are returned", pQInfo->qId, pRuntimeEnv->tableqinfoGroupInfo.numOfTables,
            pRuntimeEnv->resultInfo.total);
   } else {
-    qDebug("QInfo:%"PRIu64" query paused, %d rows returned, numOfTotal:%" PRId64 " rows",
+    qDebug("QInfo:0x%"PRIx64" query paused, %d rows returned, numOfTotal:%" PRId64 " rows",
            pQInfo->qId, GET_NUM_OF_RESULTS(pRuntimeEnv), pRuntimeEnv->resultInfo.total + GET_NUM_OF_RESULTS(pRuntimeEnv));
   }
 
@@ -258,13 +262,13 @@ int32_t qRetrieveQueryResultInfo(qinfo_t qinfo, bool* buildRes, void* pRspContex
   SQInfo *pQInfo = (SQInfo *)qinfo;
 
   if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
-    qError("QInfo:%"PRIu64" invalid qhandle", pQInfo->qId);
+    qError("QInfo:0x%"PRIx64" invalid qhandle", pQInfo->qId);
     return TSDB_CODE_QRY_INVALID_QHANDLE;
   }
 
   *buildRes = false;
   if (IS_QUERY_KILLED(pQInfo)) {
-    qDebug("QInfo:%"PRIu64" query is killed, code:0x%08x", pQInfo->qId, pQInfo->code);
+    qDebug("QInfo:0x%"PRIx64" query is killed, code:0x%08x", pQInfo->qId, pQInfo->code);
     return pQInfo->code;
   }
 
@@ -277,18 +281,18 @@ int32_t qRetrieveQueryResultInfo(qinfo_t qinfo, bool* buildRes, void* pRspContex
     code = pQInfo->code;
   } else {
     SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-    SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+    SQueryAttr *pQueryAttr = pQInfo->runtimeEnv.pQueryAttr;
 
     pthread_mutex_lock(&pQInfo->lock);
 
     assert(pQInfo->rspContext == NULL);
     if (pQInfo->dataReady == QUERY_RESULT_READY) {
       *buildRes = true;
-      qDebug("QInfo:%"PRIu64" retrieve result info, rowsize:%d, rows:%d, code:%s", pQInfo->qId, pQuery->resultRowSize,
+      qDebug("QInfo:0x%"PRIx64" retrieve result info, rowsize:%d, rows:%d, code:%s", pQInfo->qId, pQueryAttr->resultRowSize,
              GET_NUM_OF_RESULTS(pRuntimeEnv), tstrerror(pQInfo->code));
     } else {
       *buildRes = false;
-      qDebug("QInfo:%"PRIu64" retrieve req set query return result after paused", pQInfo->qId);
+      qDebug("QInfo:0x%"PRIx64" retrieve req set query return result after paused", pQInfo->qId);
       pQInfo->rspContext = pRspContext;
       assert(pQInfo->rspContext != NULL);
     }
@@ -307,11 +311,11 @@ int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *co
     return TSDB_CODE_QRY_INVALID_QHANDLE;
   }
 
-  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+  SQueryAttr *pQueryAttr = pQInfo->runtimeEnv.pQueryAttr;
   SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
 
   int32_t s = GET_NUM_OF_RESULTS(pRuntimeEnv);
-  size_t size = pQuery->resultRowSize * s;
+  size_t size = pQueryAttr->resultRowSize * s;
   size += sizeof(int32_t);
   size += sizeof(STableIdInfo) * taosHashGetSize(pRuntimeEnv->pTableRetrieveTsMap);
 
@@ -333,7 +337,7 @@ int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *co
     (*pRsp)->useconds = htobe64(pQInfo->summary.elapsedTime);
   }
 
-  (*pRsp)->precision = htons(pQuery->precision);
+  (*pRsp)->precision = htons(pQueryAttr->precision);
   if (GET_NUM_OF_RESULTS(&(pQInfo->runtimeEnv)) > 0 && pQInfo->code == TSDB_CODE_SUCCESS) {
     doDumpQueryResult(pQInfo, (*pRsp)->data);
   } else {
@@ -347,10 +351,10 @@ int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *co
     // here current thread hold the refcount, so it is safe to free tsdbQueryHandle.
     *continueExec = false;
     (*pRsp)->completed = 1;  // notify no more result to client
-    qDebug("QInfo:%"PRIu64" no more results to retrieve", pQInfo->qId);
+    qDebug("QInfo:0x%"PRIx64" no more results to retrieve", pQInfo->qId);
   } else {
     *continueExec = true;
-    qDebug("QInfo:%"PRIu64" has more results to retrieve", pQInfo->qId);
+    qDebug("QInfo:0x%"PRIx64" has more results to retrieve", pQInfo->qId);
   }
 
   // the memory should be freed if the code of pQInfo is not TSDB_CODE_SUCCESS
@@ -376,7 +380,7 @@ int32_t qKillQuery(qinfo_t qinfo) {
     return TSDB_CODE_QRY_INVALID_QHANDLE;
   }
 
-  qDebug("QInfo:%"PRIu64" query killed", pQInfo->qId);
+  qDebug("QInfo:0x%"PRIx64" query killed", pQInfo->qId);
   setQueryKilled(pQInfo);
 
   // Wait for the query executing thread being stopped/
@@ -404,7 +408,7 @@ void qDestroyQueryInfo(qinfo_t qHandle) {
     return;
   }
 
-  qDebug("QInfo:%"PRIu64" query completed", pQInfo->qId);
+  qDebug("QInfo:0x%"PRIx64" query completed", pQInfo->qId);
   queryCostStatis(pQInfo);   // print the query cost summary
   freeQInfo(pQInfo);
 }
@@ -487,7 +491,7 @@ void** qRegisterQInfo(void* pMgmt, uint64_t qId, void *qInfo) {
 
   SQueryMgmt *pQueryMgmt = pMgmt;
   if (pQueryMgmt->qinfoPool == NULL) {
-    qError("QInfo:%"PRIu64"-%p failed to add qhandle into qMgmt, since qMgmt is closed", qId, (void*)qInfo);
+    qError("QInfo:0x%"PRIx64"-%p failed to add qhandle into qMgmt, since qMgmt is closed", qId, (void*)qInfo);
     terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
     return NULL;
   }
@@ -495,7 +499,7 @@ void** qRegisterQInfo(void* pMgmt, uint64_t qId, void *qInfo) {
   pthread_mutex_lock(&pQueryMgmt->lock);
   if (pQueryMgmt->closed) {
     pthread_mutex_unlock(&pQueryMgmt->lock);
-    qError("QInfo:%"PRIu64"-%p failed to add qhandle into cache, since qMgmt is colsing", qId, (void*)qInfo);
+    qError("QInfo:0x%"PRIx64"-%p failed to add qhandle into cache, since qMgmt is colsing", qId, (void*)qInfo);
     terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
     return NULL;
   } else {

src/tsdb/src/tsdbRead.c

@@ -123,7 +123,7 @@ typedef struct STsdbQueryHandle {
   SMemRef       *pMemRef;
   SArray        *defaultLoadColumn;// default load column
   SDataBlockLoadInfo dataBlockLoadInfo; /* record current block load information */
-  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQuery */
+  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQueryAttr */
 
   SArray        *prev;             // previous row which is before than time window
   SArray        *next;             // next row which is after the query time window
@@ -286,7 +286,7 @@ static SArray* createCheckInfoFromTableGroup(STsdbQueryHandle* pQueryHandle, STa
       }
 
       taosArrayPush(pTableCheckInfo, &info);
-      tsdbDebug("%p check table uid:%"PRId64", tid:%d from lastKey:%"PRId64" %"PRIu64, pQueryHandle, info.tableId.uid,
+      tsdbDebug("%p check table uid:%"PRId64", tid:%d from lastKey:%"PRId64" 0x%"PRIx64, pQueryHandle, info.tableId.uid,
                 info.tableId.tid, info.lastKey, pQueryHandle->qId);
     }
   }
@@ -440,7 +440,7 @@ TsdbQueryHandleT* tsdbQueryTables(STsdbRepo* tsdb, STsdbQueryCond* pCond, STable
 
   tsdbMayTakeMemSnapshot(pQueryHandle, psTable);
 
-  tsdbDebug("%p total numOfTable:%" PRIzu " in query, %"PRIu64, pQueryHandle, taosArrayGetSize(pQueryHandle->pTableCheckInfo), pQueryHandle->qId);
+  tsdbDebug("%p total numOfTable:%" PRIzu " in query, 0x%"PRIx64, pQueryHandle, taosArrayGetSize(pQueryHandle->pTableCheckInfo), pQueryHandle->qId);
   return (TsdbQueryHandleT) pQueryHandle;
 }
 
@@ -651,7 +651,7 @@ static bool initTableMemIterator(STsdbQueryHandle* pHandle, STableCheckInfo* pCh
     SDataRow row = (SDataRow)SL_GET_NODE_DATA(node);
     TSKEY key = dataRowKey(row);  // first timestamp in buffer
     tsdbDebug("%p uid:%" PRId64 ", tid:%d check data in mem from skey:%" PRId64 ", order:%d, ts range in buf:%" PRId64
-              "-%" PRId64 ", lastKey:%" PRId64 ", numOfRows:%"PRId64", %"PRIu64,
+              "-%" PRId64 ", lastKey:%" PRId64 ", numOfRows:%"PRId64", 0x%"PRIx64,
               pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, key, order, pMem->keyFirst, pMem->keyLast,
               pCheckInfo->lastKey, pMem->numOfRows, pHandle->qId);
 
@@ -662,7 +662,7 @@ static bool initTableMemIterator(STsdbQueryHandle* pHandle, STableCheckInfo* pCh
     }
 
   } else {
-    tsdbDebug("%p uid:%"PRId64", tid:%d no data in mem, %"PRIu64, pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid,
+    tsdbDebug("%p uid:%"PRId64", tid:%d no data in mem, 0x%"PRIx64, pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid,
         pHandle->qId);
   }
 
@@ -673,7 +673,7 @@ static bool initTableMemIterator(STsdbQueryHandle* pHandle, STableCheckInfo* pCh
     SDataRow row = (SDataRow)SL_GET_NODE_DATA(node);
     TSKEY key = dataRowKey(row);  // first timestamp in buffer
     tsdbDebug("%p uid:%" PRId64 ", tid:%d check data in imem from skey:%" PRId64 ", order:%d, ts range in buf:%" PRId64
-              "-%" PRId64 ", lastKey:%" PRId64 ", numOfRows:%"PRId64", %"PRIu64,
+              "-%" PRId64 ", lastKey:%" PRId64 ", numOfRows:%"PRId64", 0x%"PRIx64,
               pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, key, order, pIMem->keyFirst, pIMem->keyLast,
               pCheckInfo->lastKey, pIMem->numOfRows, pHandle->qId);
 
@@ -683,7 +683,7 @@ static bool initTableMemIterator(STsdbQueryHandle* pHandle, STableCheckInfo* pCh
       assert(pCheckInfo->lastKey >= key);
     }
   } else {
-    tsdbDebug("%p uid:%"PRId64", tid:%d no data in imem, %"PRIu64, pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid,
+    tsdbDebug("%p uid:%"PRId64", tid:%d no data in imem, 0x%"PRIx64, pHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid,
         pHandle->qId);
   }
 
@@ -811,7 +811,7 @@ static bool hasMoreDataInCache(STsdbQueryHandle* pHandle) {
   }
 
   pCheckInfo->lastKey = dataRowKey(row);  // first timestamp in buffer
-  tsdbDebug("%p uid:%" PRId64", tid:%d check data in buffer from skey:%" PRId64 ", order:%d, %"PRIu64, pHandle,
+  tsdbDebug("%p uid:%" PRId64", tid:%d check data in buffer from skey:%" PRId64 ", order:%d, 0x%"PRIx64, pHandle,
       pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, pCheckInfo->lastKey, pHandle->order, pHandle->qId);
 
   // all data in mem are checked already.
@@ -986,21 +986,21 @@ static int32_t doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SBlock* pBloc
   STSchema *pSchema = tsdbGetTableSchema(pCheckInfo->pTableObj);
   int32_t   code = tdInitDataCols(pQueryHandle->pDataCols, pSchema);
   if (code != TSDB_CODE_SUCCESS) {
-    tsdbError("%p failed to malloc buf for pDataCols, %"PRIu64, pQueryHandle, pQueryHandle->qId);
+    tsdbError("%p failed to malloc buf for pDataCols, 0x%"PRIx64, pQueryHandle, pQueryHandle->qId);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     goto _error;
   }
 
   code = tdInitDataCols(pQueryHandle->rhelper.pDCols[0], pSchema);
   if (code != TSDB_CODE_SUCCESS) {
-    tsdbError("%p failed to malloc buf for rhelper.pDataCols[0], %"PRIu64, pQueryHandle, pQueryHandle->qId);
+    tsdbError("%p failed to malloc buf for rhelper.pDataCols[0], 0x%"PRIx64, pQueryHandle, pQueryHandle->qId);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     goto _error;
   }
 
   code = tdInitDataCols(pQueryHandle->rhelper.pDCols[1], pSchema);
   if (code != TSDB_CODE_SUCCESS) {
-    tsdbError("%p failed to malloc buf for rhelper.pDataCols[1], %"PRIu64, pQueryHandle, pQueryHandle->qId);
+    tsdbError("%p failed to malloc buf for rhelper.pDataCols[1], 0x%"PRIx64, pQueryHandle, pQueryHandle->qId);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     goto _error;
   }
@@ -1036,14 +1036,14 @@ static int32_t doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SBlock* pBloc
   int64_t elapsedTime = (taosGetTimestampUs() - st);
   pQueryHandle->cost.blockLoadTime += elapsedTime;
 
-  tsdbDebug("%p load file block into buffer, index:%d, brange:%"PRId64"-%"PRId64", rows:%d, elapsed time:%"PRId64 " us, %"PRIu64,
+  tsdbDebug("%p load file block into buffer, index:%d, brange:%"PRId64"-%"PRId64", rows:%d, elapsed time:%"PRId64 " us, 0x%"PRIx64,
       pQueryHandle, slotIndex, pBlock->keyFirst, pBlock->keyLast, pBlock->numOfRows, elapsedTime, pQueryHandle->qId);
   return TSDB_CODE_SUCCESS;
 
 _error:
   pBlock->numOfRows = 0;
 
-  tsdbError("%p error occurs in loading file block, index:%d, brange:%"PRId64"-%"PRId64", rows:%d, %"PRIu64,
+  tsdbError("%p error occurs in loading file block, index:%d, brange:%"PRId64"-%"PRId64", rows:%d, 0x%"PRIx64,
             pQueryHandle, slotIndex, pBlock->keyFirst, pBlock->keyLast, pBlock->numOfRows, pQueryHandle->qId);
   return terrno;
 }
@@ -1066,7 +1066,7 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SBlock* p
   assert(cur->pos >= 0 && cur->pos <= binfo.rows);
 
   TSKEY key = (row != NULL)? dataRowKey(row):TSKEY_INITIAL_VAL;
-  tsdbDebug("%p key in mem:%"PRId64", %"PRIu64, pQueryHandle, key, pQueryHandle->qId);
+  tsdbDebug("%p key in mem:%"PRId64", 0x%"PRIx64, pQueryHandle, key, pQueryHandle->qId);
 
   if ((ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key <= binfo.window.ekey)) ||
       (!ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key >= binfo.window.skey))) {
@@ -1406,7 +1406,11 @@ static void copyOneRowFromMem(STsdbQueryHandle* pQueryHandle, int32_t capacity,
           SET_DOUBLE_PTR(pData, value);
           break;
         case TSDB_DATA_TYPE_TIMESTAMP:
-          *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+            *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+          } else {
+            *(TSKEY *)pData = *(TSKEY *)value;
+          }
           break;
         default:
           memcpy(pData, value, pColInfo->info.bytes);
@@ -1547,7 +1551,7 @@ static void copyAllRemainRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STabl
   updateInfoAfterMerge(pQueryHandle, pCheckInfo, numOfRows, pos);
   doCheckGeneratedBlockRange(pQueryHandle);
 
-  tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, %"PRIu64,
+  tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, 0x%"PRIx64,
             pQueryHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, cur->mixBlock, cur->win.skey,
             cur->win.ekey, cur->rows, pQueryHandle->qId);
 }
@@ -1601,7 +1605,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
   int32_t endPos = getEndPosInDataBlock(pQueryHandle, &blockInfo);
 
   tsdbDebug("%p uid:%" PRIu64",tid:%d start merge data block, file block range:%"PRIu64"-%"PRIu64" rows:%d, start:%d,"
-            "end:%d, %"PRIu64,
+            "end:%d, 0x%"PRIx64,
             pQueryHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, blockInfo.window.skey, blockInfo.window.ekey,
             blockInfo.rows, cur->pos, endPos, pQueryHandle->qId);
 
@@ -1743,7 +1747,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
   updateInfoAfterMerge(pQueryHandle, pCheckInfo, numOfRows, pos);
   doCheckGeneratedBlockRange(pQueryHandle);
 
-  tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, %"PRIu64,
+  tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, 0x%"PRIx64,
       pQueryHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, cur->mixBlock, cur->win.skey,
       cur->win.ekey, cur->rows, pQueryHandle->qId);
 }
@@ -1919,12 +1923,12 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
     memcpy(pQueryHandle->pDataBlockInfo, sup.pDataBlockInfo[0], sizeof(STableBlockInfo) * numOfBlocks);
     cleanBlockOrderSupporter(&sup, numOfQualTables);
 
-    tsdbDebug("%p create data blocks info struct completed for 1 table, %d blocks not sorted %"PRIu64, pQueryHandle, cnt,
+    tsdbDebug("%p create data blocks info struct completed for 1 table, %d blocks not sorted 0x%"PRIx64, pQueryHandle, cnt,
         pQueryHandle->qId);
     return TSDB_CODE_SUCCESS;
   }
 
-  tsdbDebug("%p create data blocks info struct completed, %d blocks in %d tables %"PRIu64, pQueryHandle, cnt,
+  tsdbDebug("%p create data blocks info struct completed, %d blocks in %d tables 0x%"PRIx64, pQueryHandle, cnt,
       numOfQualTables, pQueryHandle->qId);
 
   assert(cnt <= numOfBlocks && numOfQualTables <= numOfTables);  // the pTableQueryInfo[j]->numOfBlocks may be 0
@@ -1961,7 +1965,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
    * }
    */
 
-  tsdbDebug("%p %d data blocks sort completed, %"PRIu64, pQueryHandle, cnt, pQueryHandle->qId);
+  tsdbDebug("%p %d data blocks sort completed, 0x%"PRIx64, pQueryHandle, cnt, pQueryHandle->qId);
   cleanBlockOrderSupporter(&sup, numOfTables);
   free(pTree);
 
@@ -2019,7 +2023,7 @@ static int32_t getFirstFileDataBlock(STsdbQueryHandle* pQueryHandle, bool* exist
     if ((ASCENDING_TRAVERSE(pQueryHandle->order) && win.skey > pQueryHandle->window.ekey) ||
         (!ASCENDING_TRAVERSE(pQueryHandle->order) && win.ekey < pQueryHandle->window.ekey)) {
       tsdbUnLockFS(REPO_FS(pQueryHandle->pTsdb));
-      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, %"PRIu64, pQueryHandle,
+      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, 0x%"PRIx64, pQueryHandle,
                 pQueryHandle->window.skey, pQueryHandle->window.ekey, pQueryHandle->qId);
       pQueryHandle->pFileGroup = NULL;
       assert(pQueryHandle->numOfBlocks == 0);
@@ -2043,7 +2047,7 @@ static int32_t getFirstFileDataBlock(STsdbQueryHandle* pQueryHandle, bool* exist
       break;
     }
 
-    tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %"PRIu64, pQueryHandle, numOfBlocks, numOfTables,
+    tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, 0x%"PRIx64, pQueryHandle, numOfBlocks, numOfTables,
               pQueryHandle->pFileGroup->fid, pQueryHandle->qId);
 
     assert(numOfBlocks >= 0);
@@ -2135,7 +2139,7 @@ int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist
     if ((ASCENDING_TRAVERSE(pQueryHandle->order) && win.skey > pQueryHandle->window.ekey) ||
         (!ASCENDING_TRAVERSE(pQueryHandle->order) && win.ekey < pQueryHandle->window.ekey)) {
       tsdbUnLockFS(REPO_FS(pQueryHandle->pTsdb));
-      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, %"PRIu64, pQueryHandle,
+      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, 0x%"PRIx64, pQueryHandle,
                 pQueryHandle->window.skey, pQueryHandle->window.ekey, pQueryHandle->qId);
       pQueryHandle->pFileGroup = NULL;
       break;
@@ -2159,7 +2163,7 @@ int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist
       break;
     }
 
-    tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %"PRIu64, pQueryHandle, numOfBlocks, numOfTables,
+    tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, 0x%"PRIx64, pQueryHandle, numOfBlocks, numOfTables,
               pQueryHandle->pFileGroup->fid, pQueryHandle->qId);
 
     if (numOfBlocks == 0) {
@@ -2207,7 +2211,7 @@ static int32_t getDataBlocksInFiles(STsdbQueryHandle* pQueryHandle, bool* exists
     if ((!cur->mixBlock) || cur->blockCompleted) {
       // all data blocks in current file has been checked already, try next file if exists
     } else {
-      tsdbDebug("%p continue in current data block, index:%d, pos:%d, %"PRIu64, pQueryHandle, cur->slot, cur->pos,
+      tsdbDebug("%p continue in current data block, index:%d, pos:%d, 0x%"PRIx64, pQueryHandle, cur->slot, cur->pos,
                 pQueryHandle->qId);
       int32_t code = handleDataMergeIfNeeded(pQueryHandle, pBlockInfo->compBlock, pCheckInfo);
       *exists = (pQueryHandle->realNumOfRows > 0);
@@ -2336,7 +2340,7 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
   }
 
   int64_t elapsedTime = taosGetTimestampUs() - st;
-  tsdbDebug("%p build data block from cache completed, elapsed time:%"PRId64" us, numOfRows:%d, numOfCols:%d, %"PRIu64, pQueryHandle,
+  tsdbDebug("%p build data block from cache completed, elapsed time:%"PRId64" us, numOfRows:%d, numOfCols:%d, 0x%"PRIx64, pQueryHandle,
             elapsedTime, numOfRows, numOfCols, pQueryHandle->qId);
 
   return numOfRows;
@@ -3206,9 +3210,10 @@ int32_t tsdbQuerySTableByTagCond(STsdbRepo* tsdb, uint64_t uid, TSKEY skey, cons
     pGroupInfo->numOfTables = (uint32_t) taosArrayGetSize(res);
     pGroupInfo->pGroupList  = createTableGroup(res, pTagSchema, pColIndex, numOfCols, skey);
 
-    tsdbDebug("%p no table name/tag condition, all tables belong to one group, numOfTables:%u", tsdb, pGroupInfo->numOfTables);
+    tsdbDebug("%p no table name/tag condition, all tables qualified, numOfTables:%u, group:%zu", tsdb,
-    taosArrayDestroy(res);
+              pGroupInfo->numOfTables, taosArrayGetSize(pGroupInfo->pGroupList));
 
+    taosArrayDestroy(res);
     if (tsdbUnlockRepoMeta(tsdb) < 0) goto _error;
     return ret;
   }
@@ -3391,7 +3396,7 @@ void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle) {
   pQueryHandle->next = doFreeColumnInfoData(pQueryHandle->next);
 
   SIOCostSummary* pCost = &pQueryHandle->cost;
-  tsdbDebug("%p :io-cost summary: statis-info:%"PRId64" us, datablock:%" PRId64" us, check data:%"PRId64" us, %"PRIu64,
+  tsdbDebug("%p :io-cost summary: statis-info:%"PRId64" us, datablock:%" PRId64" us, check data:%"PRId64" us, 0x%"PRIx64,
       pQueryHandle, pCost->statisInfoLoadTime, pCost->blockLoadTime, pCost->checkForNextTime, pQueryHandle->qId);
 
   tfree(pQueryHandle);
@@ -3408,14 +3413,16 @@ void tsdbDestroyTableGroup(STableGroupInfo *pGroupList) {
     size_t numOfTables = taosArrayGetSize(p);
     for(int32_t j = 0; j < numOfTables; ++j) {
       STable* pTable = taosArrayGetP(p, j);
-      assert(pTable != NULL);
+      if (pTable != NULL) { // in case of handling retrieve data from tsdb
-
+        tsdbUnRefTable(pTable);
-      tsdbUnRefTable(pTable);
+      }
+      //assert(pTable != NULL);
     }
 
     taosArrayDestroy(p);
   }
 
+  taosHashCleanup(pGroupList->map);
   taosArrayDestroy(pGroupList->pGroupList);
   pGroupList->numOfTables = 0;
 }
@@ -3426,7 +3433,7 @@ static void applyFilterToSkipListNode(SSkipList *pSkipList, tExprNode *pExpr, SA
   // Scan each node in the skiplist by using iterator
   while (tSkipListIterNext(iter)) {
     SSkipListNode *pNode = tSkipListIterGet(iter);
-    if (exprTreeApplayFilter(pExpr, pNode, param)) {
+    if (exprTreeApplyFilter(pExpr, pNode, param)) {
       taosArrayPush(pResult, &(SL_GET_NODE_DATA(pNode)));
     }
   }

src/util/src/tcompare.c

@@ -398,6 +398,10 @@ int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size) {
     case TSDB_DATA_TYPE_SMALLINT:   DEFAULT_COMP(GET_INT16_VAL(f1), GET_INT16_VAL(f2));
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_BOOL:       DEFAULT_COMP(GET_INT8_VAL(f1), GET_INT8_VAL(f2));
+    case TSDB_DATA_TYPE_UTINYINT:   DEFAULT_COMP(GET_UINT8_VAL(f1), GET_UINT8_VAL(f2));
+    case TSDB_DATA_TYPE_USMALLINT:  DEFAULT_COMP(GET_UINT16_VAL(f1), GET_UINT16_VAL(f2));
+    case TSDB_DATA_TYPE_UINT:       DEFAULT_COMP(GET_UINT32_VAL(f1), GET_UINT32_VAL(f2));
+    case TSDB_DATA_TYPE_UBIGINT:    DEFAULT_COMP(GET_UINT64_VAL(f1), GET_UINT64_VAL(f2));
     case TSDB_DATA_TYPE_NCHAR: {
       tstr* t1 = (tstr*) f1;
       tstr* t2 = (tstr*) f2;

src/util/src/tcrc32c.c

@@ -736,7 +736,7 @@ static uint32_t table[16][256] = {
      0x9c221d09, 0x6e2e10f7, 0x7dd67004, 0x8fda7dfa}
 
 };
-#ifndef _TD_ARM_
+#if !defined(_TD_ARM_) && !defined(_TD_MIPS_)
 static uint32_t long_shifts[4][256] = {
     {0x00000000, 0xe040e0ac, 0xc56db7a9, 0x252d5705, 0x8f3719a3, 0x6f77f90f,
      0x4a5aae0a, 0xaa1a4ea6, 0x1b8245b7, 0xfbc2a51b, 0xdeeff21e, 0x3eaf12b2,
@@ -1187,7 +1187,7 @@ uint32_t crc32c_sf(uint32_t crci, crc_stream input, size_t length) {
   }
   return (uint32_t)crc ^ 0xffffffff;
 }
-#ifndef _TD_ARM_
+#if !defined(_TD_ARM_) && !defined(_TD_MIPS_)
 /* Apply the zeros operator table to crc. */
 static uint32_t shift_crc(uint32_t shift_table[][256], uint32_t crc) {
   return shift_table[0][crc & 0xff] ^ shift_table[1][(crc >> 8) & 0xff] ^
@@ -1198,7 +1198,7 @@ static uint32_t shift_crc(uint32_t shift_table[][256], uint32_t crc) {
    version.  Otherwise, use the software version. */
 uint32_t (*crc32c)(uint32_t crci, crc_stream bytes, size_t len) = crc32c_sf;
 
-#ifndef _TD_ARM_
+#if !defined(_TD_ARM_) && !defined(_TD_MIPS_)
 /* Compute CRC-32C using the Intel hardware instruction. */
 uint32_t crc32c_hw(uint32_t crc, crc_stream buf, size_t len) {
   crc_stream next = buf;
@@ -1353,7 +1353,7 @@ uint32_t crc32c_hw(uint32_t crc, crc_stream buf, size_t len) {
 #endif // #ifndef _TD_ARM_
 
 void taosResolveCRC() {
-#if defined _TD_ARM_ || defined WINDOWS
+#if defined _TD_ARM_ || defined _TD_MIPS_ || defined WINDOWS
   crc32c = crc32c_sf;
 #else
   int sse42;

src/util/src/tlog.c

@@ -416,7 +416,8 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
     }
   }
 
-  if (dflag & DEBUG_SCREEN) taosWrite(1, buffer, (uint32_t)len);
+  if (dflag & DEBUG_SCREEN)
+      taosWrite(1, buffer, (uint32_t)len);
   if (dflag == 255) nInfo(buffer, len);
 }
 

src/util/src/tnettest.c

@@ -291,16 +291,16 @@ static void taosNetCheckPort(uint32_t hostIp, int32_t startPort, int32_t endPort
     info.port = port;
     ret = taosNetCheckTcpPort(&info);
     if (ret != 0) {
-      uError("failed to test TCP port:%d", port);
+      printf("failed to test TCP port:%d\n", port);
     } else {
-      uInfo("successed to test TCP port:%d", port);
+      printf("successed to test TCP port:%d\n", port);
     }
 
     ret = taosNetCheckUdpPort(&info);
     if (ret != 0) {
-      uError("failed to test UDP port:%d", port);
+      printf("failed to test UDP port:%d\n", port);
     } else {
-      uInfo("successed to test UDP port:%d", port);
+      printf("successed to test UDP port:%d\n", port);
     }
   }
 }
@@ -464,9 +464,9 @@ static void taosNetTestRpc(char *host, int32_t startPort, int32_t pkgLen) {
 
     int32_t ret = taosNetCheckRpc(host, port, sendpkgLen, spi, NULL);
     if (ret < 0) {
-      uError("failed to test TCP port:%d", port);
+      printf("failed to test TCP port:%d\n", port);
     } else {
-      uInfo("successed to test TCP port:%d", port);
+      printf("successed to test TCP port:%d\n", port);
     }
 
     if (pkgLen >= tsRpcMaxUdpSize) {
@@ -477,9 +477,9 @@ static void taosNetTestRpc(char *host, int32_t startPort, int32_t pkgLen) {
 
     ret = taosNetCheckRpc(host, port, pkgLen, spi, NULL);
     if (ret < 0) {
-      uError("failed to test UDP port:%d", port);
+      printf("failed to test UDP port:%d\n", port);
     } else {
-      uInfo("successed to test UDP port:%d", port);
+      printf("successed to test UDP port:%d\n", port);
     }
   }
 
@@ -539,7 +539,7 @@ static void taosNetTestServer(char *host, int32_t startPort, int32_t pkgLen) {
 }
 
 void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen) {
-  tscEmbedded = 1;
+//  tscEmbedded = 1;
   if (host == NULL) host = tsLocalFqdn;
   if (port == 0) port = tsServerPort;
   if (pkgLen <= 10) pkgLen = 1000;
@@ -559,5 +559,5 @@ void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen) {
     taosNetTestStartup(host, port);
   }
 
-  tscEmbedded = 0;
+//  tscEmbedded = 0;
 }

src/util/src/ttimer.c

@@ -538,7 +538,7 @@ static void taosTmrModuleInit(void) {
 
 void* taosTmrInit(int maxNumOfTmrs, int resolution, int longest, const char* label) {
   const char* ret = monotonicInit();
-  tmrInfo("ttimer monotonic clock source:%s", ret);
+  tmrDebug("ttimer monotonic clock source:%s", ret);
 
   pthread_once(&tmrModuleInit, taosTmrModuleInit);
 

src/vnode/src/vnodeRead.c

@@ -183,7 +183,7 @@ static int32_t vnodeDumpQueryResult(SRspRet *pRet, void *pVnode, uint64_t qId, v
       }
     } else {
       *freeHandle = true;
-      vTrace("QInfo:%"PRIu64"-%p exec completed, free handle:%d", qId, *handle, *freeHandle);
+      vTrace("QInfo:0x%"PRIx64"-%p exec completed, free handle:%d", qId, *handle, *freeHandle);
     }
   } else {
     SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
@@ -232,7 +232,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
 
     SQueryTableRsp *pRsp = (SQueryTableRsp *)rpcMallocCont(sizeof(SQueryTableRsp));
     pRsp->code = code;
-    pRsp->qhandle = 0;
+    pRsp->qId  = 0;
 
     pRet->len = sizeof(SQueryTableRsp);
     pRet->rsp = pRsp;
@@ -244,18 +244,18 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
       if (handle == NULL) {  // failed to register qhandle
         pRsp->code = terrno;
         terrno = 0;
-        vError("vgId:%d, QInfo:%"PRIu64 "-%p register qhandle failed, return to app, code:%s", pVnode->vgId, qId, (void *)pQInfo,
+        vError("vgId:%d, QInfo:0x%"PRIx64 "-%p register qhandle failed, return to app, code:%s", pVnode->vgId, qId, (void *)pQInfo,
                tstrerror(pRsp->code));
         qDestroyQueryInfo(pQInfo);  // destroy it directly
         return pRsp->code;
       } else {
         assert(*handle == pQInfo);
-        pRsp->qhandle = htobe64(qId);
+        pRsp->qId = htobe64(qId);
       }
 
       if (handle != NULL &&
           vnodeNotifyCurrentQhandle(pRead->rpcHandle, qId, *handle, pVnode->vgId) != TSDB_CODE_SUCCESS) {
-        vError("vgId:%d, QInfo:%"PRIu64 "-%p, query discarded since link is broken, %p", pVnode->vgId, qId, *handle,
+        vError("vgId:%d, QInfo:0x%"PRIx64 "-%p, query discarded since link is broken, %p", pVnode->vgId, qId, *handle,
                pRead->rpcHandle);
         pRsp->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
         qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
@@ -266,7 +266,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
     }
 
     if (handle != NULL) {
-      vTrace("vgId:%d, QInfo:%"PRIu64 "-%p, dnode query msg disposed, create qhandle and returns to app", vgId, qId, *handle);
+      vTrace("vgId:%d, QInfo:0x%"PRIx64 "-%p, dnode query msg disposed, create qhandle and returns to app", vgId, qId, *handle);
       code = vnodePutItemIntoReadQueue(pVnode, handle, pRead->rpcHandle);
       if (code != TSDB_CODE_SUCCESS) {
         pRsp->code = code;
@@ -324,14 +324,14 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
 }
 
 static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
-  void *   pCont = pRead->pCont;
+  void    *pCont = pRead->pCont;
-  SRspRet *pRet = &pRead->rspRet;
+  SRspRet *pRet  = &pRead->rspRet;
 
   SRetrieveTableMsg *pRetrieve = pCont;
   pRetrieve->free = htons(pRetrieve->free);
   pRetrieve->qId = htobe64(pRetrieve->qId);
 
-  vTrace("vgId:%d, qId:%" PRIu64 ", retrieve msg is disposed, free:%d, conn:%p", pVnode->vgId, pRetrieve->qId,
+  vTrace("vgId:%d, qId:0x%" PRIx64 ", retrieve msg is disposed, free:%d, conn:%p", pVnode->vgId, pRetrieve->qId,
          pRetrieve->free, pRead->rpcHandle);
 
   memset(pRet, 0, sizeof(SRspRet));
@@ -383,7 +383,7 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
     memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
     freeHandle = true;
   } else {  // result is not ready, return immediately
-    // Only effects in the non-blocking model
+    // Only affects the non-blocking model
     if (!tsRetrieveBlockingModel) {
       if (!buildRes) {
         assert(pRead->rpcHandle != NULL);
@@ -414,7 +414,7 @@ int32_t vnodeNotifyCurrentQhandle(void *handle, uint64_t qId, void *qhandle, int
   pMsg->header.vgId = htonl(vgId);
   pMsg->header.contLen = htonl(sizeof(SRetrieveTableMsg));
 
-  vTrace("QInfo:%"PRIu64"-%p register qhandle to connect:%p", qId, qhandle, handle);
+  vTrace("QInfo:0x%"PRIx64"-%p register qhandle to connect:%p", qId, qhandle, handle);
   return rpcReportProgress(handle, (char *)pMsg, sizeof(SRetrieveTableMsg));
 }
 

tests/examples/C#/C#checker/C#checker.cs

@@ -20,358 +20,367 @@ using System.Runtime.InteropServices;
 using System.Collections;
 
 namespace TDengineDriver
-{
+{
-    class TDengineTest
+    class TDengineTest
-    {
+    {
-        //connect parameters
+        //connect parameters
-        private string host;
+        private string host;
-        private string configDir;
+        private string configDir;
-        private string user;
+        private string user;
-        private string password;
+        private string password;
-        private short port = 0;
+        private short port = 0;
-
+
-        //sql parameters
+        //sql parameters
-        private string dbName;
+        private string dbName;
-        private string tbName;
+        private string tbName;
-
+
-
+
-        private bool isInsertData;
+        private bool isInsertData;
-        private bool isQueryData;
+        private bool isQueryData;
-
+
-        private long tableCount;
+        private long tableCount;
-        private long totalRows;
+        private long totalRows;
-        private long batchRows;
+        private long batchRows;
-        private long beginTimestamp = 1551369600000L;
+        private long beginTimestamp = 1551369600000L;
-
+
-        private IntPtr conn = IntPtr.Zero;
+        private IntPtr conn = IntPtr.Zero;
-        private long rowsInserted = 0;
+        private long rowsInserted = 0;
-
+
-        static void Main(string[] args)
+        static void Main(string[] args)
-        {
+        {
-            TDengineTest tester = new TDengineTest();
+            TDengineTest tester = new TDengineTest();
-            tester.ReadArgument(args);
+            tester.ReadArgument(args);
-
+
-
+
-            tester.InitTDengine();
+            tester.InitTDengine();
-            tester.ConnectTDengine();
+            tester.ConnectTDengine();
             tester.createDatabase();
-            tester.useDatabase();
+            tester.useDatabase();
             tester.checkDropTable();
             tester.createTable();
             tester.checkInsert();
             tester.checkSelect();
-            tester.checkDropTable();
+            tester.checkDropTable();
-
+
-            tester.CloseConnection();
+            tester.CloseConnection();
-
+
-
+
-
+
-        }
+        }
-
+
-        public long GetArgumentAsLong(String[] argv, String argName, int minVal, int maxVal, int defaultValue)
+        public long GetArgumentAsLong(String[] argv, String argName, int minVal, int maxVal, int defaultValue)
-        {
+        {
-            int argc = argv.Length;
+            int argc = argv.Length;
-            for (int i = 0; i < argc; ++i)
+            for (int i = 0; i < argc; ++i)
-            {
+            {
-                if (argName != argv[i])
+                if (argName != argv[i])
-                {
+                {
-                    continue;
+                    continue;
-                }
+                }
-                if (i < argc - 1)
+                if (i < argc - 1)
-                {
+                {
-                    String tmp = argv[i + 1];
+                    String tmp = argv[i + 1];
-                    if (tmp[0] == '-')
+                    if (tmp[0] == '-')
-                    {
+                    {
-                        Console.WriteLine("option {0:G} requires an argument", tmp);
+                        Console.WriteLine("option {0:G} requires an argument", tmp);
-                        ExitProgram();
+                        ExitProgram();
-                    }
+                    }
-
+
-                    long tmpVal = Convert.ToInt64(tmp);
+                    long tmpVal = Convert.ToInt64(tmp);
-                    if (tmpVal < minVal || tmpVal > maxVal)
+                    if (tmpVal < minVal || tmpVal > maxVal)
-                    {
+                    {
-                        Console.WriteLine("option {0:G} should in range [{1:G}, {2:G}]", argName, minVal, maxVal);
+                        Console.WriteLine("option {0:G} should in range [{1:G}, {2:G}]", argName, minVal, maxVal);
-                        ExitProgram();
+                        ExitProgram();
-                    }
+                    }
-
+
-                    return tmpVal;
+                    return tmpVal;
-                }
+                }
-            }
+            }
-
+
-            return defaultValue;
+            return defaultValue;
-        }
+        }
-
+
-        public String GetArgumentAsString(String[] argv, String argName, String defaultValue)
+        public String GetArgumentAsString(String[] argv, String argName, String defaultValue)
-        {
+        {
-            int argc = argv.Length;
+            int argc = argv.Length;
-            for (int i = 0; i < argc; ++i)
+            for (int i = 0; i < argc; ++i)
-            {
+            {
-                if (argName != argv[i])
+                if (argName != argv[i])
-                {
+                {
-                    continue;
+                    continue;
-                }
+                }
-                if (i < argc - 1)
+                if (i < argc - 1)
-                {
+                {
-                    String tmp = argv[i + 1];
+                    String tmp = argv[i + 1];
-                    if (tmp[0] == '-')
+                    if (tmp[0] == '-')
-                    {
+                    {
-                        Console.WriteLine("option {0:G} requires an argument", tmp);
+                        Console.WriteLine("option {0:G} requires an argument", tmp);
-                        ExitProgram();
+                        ExitProgram();
-                    }
+                    }
-                    return tmp;
+                    return tmp;
-                }
+                }
-            }
+            }
-
+
-            return defaultValue;
+            return defaultValue;
-        }
+        }
-
+
-        public void PrintHelp(String[] argv)
+        public void PrintHelp(String[] argv)
-        {
+        {
-            for (int i = 0; i < argv.Length; ++i)
+            for (int i = 0; i < argv.Length; ++i)
-            {
+            {
-                if ("--help" == argv[i])
+                if ("--help" == argv[i])
-                {
+                {
-                    String indent = "    ";
+                    String indent = "    ";
-                    Console.WriteLine("taosTest is simple example to operate TDengine use C# Language.\n");
+                    Console.WriteLine("taosTest is simple example to operate TDengine use C# Language.\n");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-h");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-h");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "TDEngine server IP address to connect");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "TDEngine server IP address to connect");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-u");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-u");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "The TDEngine user name to use when connecting to the server, default is root");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "The TDEngine user name to use when connecting to the server, default is root");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-p");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-p");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "The TDEngine user name to use when connecting to the server, default is taosdata");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "The TDEngine user name to use when connecting to the server, default is taosdata");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-d");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-d");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Database used to create table or import data, default is db");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Database used to create table or import data, default is db");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-s");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-s");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Super Tables used to create table, default is mt");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Super Tables used to create table, default is mt");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-t");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-t");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Table prefixs, default is t");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Table prefixs, default is t");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-w");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-w");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Whether to insert data");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Whether to insert data");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-r");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-r");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Whether to query data");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Whether to query data");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-n");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-n");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many Tables to create, default is 10");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many Tables to create, default is 10");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-b");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-b");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many rows per insert batch, default is 10");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many rows per insert batch, default is 10");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-i");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-i");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many rows to insert, default is 100");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "How many rows to insert, default is 100");
-                    Console.WriteLine("{0:G}{1:G}", indent, "-c");
+                    Console.WriteLine("{0:G}{1:G}", indent, "-c");
-                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Configuration directory");
+                    Console.WriteLine("{0:G}{1:G}{2:G}", indent, indent, "Configuration directory");
-
+
-                    ExitProgram();
+                    ExitProgram();
-                }
+                }
-            }
+            }
-        }
+        }
-
+
-        public void ReadArgument(String[] argv)
+        public void ReadArgument(String[] argv)
-        {
+        {
-            PrintHelp(argv);
+            PrintHelp(argv);
-            host = this.GetArgumentAsString(argv, "-h", "127.0.0.1");
+            host = this.GetArgumentAsString(argv, "-h", "127.0.0.1");
-            user = this.GetArgumentAsString(argv, "-u", "root");
+            user = this.GetArgumentAsString(argv, "-u", "root");
-            password = this.GetArgumentAsString(argv, "-p", "taosdata");
+            password = this.GetArgumentAsString(argv, "-p", "taosdata");
-            dbName = this.GetArgumentAsString(argv, "-db", "test");
+            dbName = this.GetArgumentAsString(argv, "-db", "test");
-            tbName = this.GetArgumentAsString(argv, "-s", "weather");
+            tbName = this.GetArgumentAsString(argv, "-s", "weather");
-
+
-            isInsertData = this.GetArgumentAsLong(argv, "-w", 0, 1, 1) != 0;
+            isInsertData = this.GetArgumentAsLong(argv, "-w", 0, 1, 1) != 0;
-            isQueryData = this.GetArgumentAsLong(argv, "-r", 0, 1, 1) != 0;
+            isQueryData = this.GetArgumentAsLong(argv, "-r", 0, 1, 1) != 0;
-            tableCount = this.GetArgumentAsLong(argv, "-n", 1, 10000, 10);
+            tableCount = this.GetArgumentAsLong(argv, "-n", 1, 10000, 10);
-            batchRows = this.GetArgumentAsLong(argv, "-b", 1, 1000, 500);
+            batchRows = this.GetArgumentAsLong(argv, "-b", 1, 1000, 500);
-            totalRows = this.GetArgumentAsLong(argv, "-i", 1, 10000000, 10000);
+            totalRows = this.GetArgumentAsLong(argv, "-i", 1, 10000000, 10000);
-            configDir = this.GetArgumentAsString(argv, "-c", "C:/TDengine/cfg");
+            configDir = this.GetArgumentAsString(argv, "-c", "C:/TDengine/cfg");
-        }
+        }
-
+
-        public void InitTDengine()
+        public void InitTDengine()
-        {
+        {
-            TDengine.Options((int)TDengineInitOption.TDDB_OPTION_CONFIGDIR, this.configDir);
+            TDengine.Options((int)TDengineInitOption.TDDB_OPTION_CONFIGDIR, this.configDir);
-            TDengine.Options((int)TDengineInitOption.TDDB_OPTION_SHELL_ACTIVITY_TIMER, "60");
+            TDengine.Options((int)TDengineInitOption.TDDB_OPTION_SHELL_ACTIVITY_TIMER, "60");
-            TDengine.Init();
+            TDengine.Init();
-            Console.WriteLine("get connection starting...");
+            Console.WriteLine("get connection starting...");
-        }
+        }
-
+
-        public void ConnectTDengine()
+        public void ConnectTDengine()
-        {
+        {
-            string db = "";
+            string db = "";
-            this.conn = TDengine.Connect(this.host, this.user, this.password, db, this.port);
+            this.conn = TDengine.Connect(this.host, this.user, this.password, db, this.port);
-            if (this.conn == IntPtr.Zero)
+            if (this.conn == IntPtr.Zero)
-            {
+            {
-                Console.WriteLine("connection failed: " + this.host);
+                Console.WriteLine("connection failed: " + this.host);
-                ExitProgram();
+                ExitProgram();
-            }
+            }
-            else
+            else
-            {
+            {
-                Console.WriteLine("[ OK ] Connection established.");
+                Console.WriteLine("[ OK ] Connection established.");
-            }
+            }
-        }
+        }
-        public void createDatabase()
+        public void createDatabase()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("create database if not exists ").Append(this.dbName);
+            sql.Append("create database if not exists ").Append(this.dbName);
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void useDatabase()
+        public void useDatabase()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("use ").Append(this.dbName);
+            sql.Append("use ").Append(this.dbName);
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void checkSelect()
+        public void checkSelect()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("select * from test.weather");
+            sql.Append("select * from test.weather");
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void createTable()
+        public void createTable()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("create table if not exists ").Append(this.dbName).Append(".").Append(this.tbName).Append("(ts timestamp, temperature float, humidity int)");
+            sql.Append("create table if not exists ").Append(this.dbName).Append(".").Append(this.tbName).Append("(ts timestamp, temperature float, humidity int)");
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void checkInsert()
+        public void checkInsert()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("insert into test.weather (ts, temperature, humidity) values(now, 20.5, 34)");
+            sql.Append("insert into test.weather (ts, temperature, humidity) values(now, 20.5, 34)");
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void checkDropTable()
+        public void checkDropTable()
-        {
+        {
-            StringBuilder sql = new StringBuilder();
+            StringBuilder sql = new StringBuilder();
-            sql.Append("drop table if exists ").Append(this.dbName).Append(".").Append(this.tbName).Append("");
+            sql.Append("drop table if exists ").Append(this.dbName).Append(".").Append(this.tbName).Append("");
-            execute(sql.ToString());
+            execute(sql.ToString());
-        }
+        }
-        public void execute(string sql)
+        public void execute(string sql)
-        {
+        {
-            DateTime dt1 = DateTime.Now;
+            DateTime dt1 = DateTime.Now;
-            IntPtr res = TDengine.Query(this.conn, sql.ToString());
+            IntPtr res = TDengine.Query(this.conn, sql.ToString());
-            DateTime dt2 = DateTime.Now;
+            DateTime dt2 = DateTime.Now;
-            TimeSpan span = dt2 - dt1;
+            TimeSpan span = dt2 - dt1;
-
+
-            if (res != IntPtr.Zero)
+            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
-            {
+            {
-                Console.WriteLine("[OK] time cost: " + span.ToString() + "ms, execute statement ====> " + sql.ToString());
+              Console.Write(sql.ToString() + " failure, ");
-            }
+              if (res != IntPtr.Zero) {
-            else
+                Console.Write("reason: " + TDengine.Error(res));
-            {
+              }
-                Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+              Console.WriteLine("");
-                ExitProgram();
+              ExitProgram();
-            }
+            }
-            TDengine.FreeResult(res);
+            else
-        }
+            {
-
+                Console.WriteLine(sql.ToString() + " success");
-        public void ExecuteQuery(string sql)
+            }
-        {
+            TDengine.FreeResult(res);
-
+        }
-            DateTime dt1 = DateTime.Now;
+
-            long queryRows = 0;
+        public void ExecuteQuery(string sql)
-            IntPtr res = TDengine.Query(conn, sql);
+        {
-            if (res == IntPtr.Zero)
+
-            {
+            DateTime dt1 = DateTime.Now;
-                Console.WriteLine(sql + " failure, reason: " + TDengine.Error(res));
+            long queryRows = 0;
-                ExitProgram();
+            IntPtr res = TDengine.Query(conn, sql);
-            }
+            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
-            DateTime dt2 = DateTime.Now;
+            {
-            TimeSpan span = dt2 - dt1;
+              Console.Write(sql.ToString() + " failure, ");
-            Console.WriteLine("[OK] time cost: " + span.ToString() + "ms, execute statement ====> " + sql.ToString());
+              if (res != IntPtr.Zero) {
-            int fieldCount = TDengine.FieldCount(res);
+                Console.Write("reason: " + TDengine.Error(res));
-
+              }
-            List<TDengineMeta> metas = TDengine.FetchFields(res);
+              Console.WriteLine("");
-            for (int j = 0; j < metas.Count; j++)
+              ExitProgram();
-            {
+            }
-                TDengineMeta meta = (TDengineMeta)metas[j];
+            DateTime dt2 = DateTime.Now;
-            }
+            TimeSpan span = dt2 - dt1;
-
+            Console.WriteLine("[OK] time cost: " + span.ToString() + "ms, execute statement ====> " + sql.ToString());
-            IntPtr rowdata;
+            int fieldCount = TDengine.FieldCount(res);
-            StringBuilder builder = new StringBuilder();
+
-            while ((rowdata = TDengine.FetchRows(res)) != IntPtr.Zero)
+            List<TDengineMeta> metas = TDengine.FetchFields(res);
-            {
+            for (int j = 0; j < metas.Count; j++)
-                queryRows++;
+            {
-                for (int fields = 0; fields < fieldCount; ++fields)
+                TDengineMeta meta = (TDengineMeta)metas[j];
-                {
+            }
-                    TDengineMeta meta = metas[fields];
+
-                    int offset = IntPtr.Size * fields;
+            IntPtr rowdata;
-                    IntPtr data = Marshal.ReadIntPtr(rowdata, offset);
+            StringBuilder builder = new StringBuilder();
-
+            while ((rowdata = TDengine.FetchRows(res)) != IntPtr.Zero)
-                    builder.Append("---");
+            {
-
+                queryRows++;
-                    if (data == IntPtr.Zero)
+                for (int fields = 0; fields < fieldCount; ++fields)
-                    {
+                {
-                        builder.Append("NULL");
+                    TDengineMeta meta = metas[fields];
-                        continue;
+                    int offset = IntPtr.Size * fields;
-                    }
+                    IntPtr data = Marshal.ReadIntPtr(rowdata, offset);
-
+
-                    switch ((TDengineDataType)meta.type)
+                    builder.Append("---");
-                    {
+
-                        case TDengineDataType.TSDB_DATA_TYPE_BOOL:
+                    if (data == IntPtr.Zero)
-                            bool v1 = Marshal.ReadByte(data) == 0 ? false : true;
+                    {
-                            builder.Append(v1);
+                        builder.Append("NULL");
-                            break;
+                        continue;
-                        case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
+                    }
-                            byte v2 = Marshal.ReadByte(data);
+
-                            builder.Append(v2);
+                    switch ((TDengineDataType)meta.type)
-                            break;
+                    {
-                        case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
+                        case TDengineDataType.TSDB_DATA_TYPE_BOOL:
-                            short v3 = Marshal.ReadInt16(data);
+                            bool v1 = Marshal.ReadByte(data) == 0 ? false : true;
-                            builder.Append(v3);
+                            builder.Append(v1);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_INT:
+                        case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
-                            int v4 = Marshal.ReadInt32(data);
+                            byte v2 = Marshal.ReadByte(data);
-                            builder.Append(v4);
+                            builder.Append(v2);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
+                        case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
-                            long v5 = Marshal.ReadInt64(data);
+                            short v3 = Marshal.ReadInt16(data);
-                            builder.Append(v5);
+                            builder.Append(v3);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
+                        case TDengineDataType.TSDB_DATA_TYPE_INT:
-                            float v6 = (float)Marshal.PtrToStructure(data, typeof(float));
+                            int v4 = Marshal.ReadInt32(data);
-                            builder.Append(v6);
+                            builder.Append(v4);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
+                        case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
-                            double v7 = (double)Marshal.PtrToStructure(data, typeof(double));
+                            long v5 = Marshal.ReadInt64(data);
-                            builder.Append(v7);
+                            builder.Append(v5);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_BINARY:
+                        case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
-                            string v8 = Marshal.PtrToStringAnsi(data);
+                            float v6 = (float)Marshal.PtrToStructure(data, typeof(float));
-                            builder.Append(v8);
+                            builder.Append(v6);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
+                        case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
-                            long v9 = Marshal.ReadInt64(data);
+                            double v7 = (double)Marshal.PtrToStructure(data, typeof(double));
-                            builder.Append(v9);
+                            builder.Append(v7);
-                            break;
+                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
+                        case TDengineDataType.TSDB_DATA_TYPE_BINARY:
-                            string v10 = Marshal.PtrToStringAnsi(data);
+                            string v8 = Marshal.PtrToStringAnsi(data);
-                            builder.Append(v10);
+                            builder.Append(v8);
-                            break;
+                            break;
-                    }
+                        case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
-                }
+                            long v9 = Marshal.ReadInt64(data);
-                builder.Append("---");
+                            builder.Append(v9);
-
+                            break;
-                if (queryRows <= 10)
+                        case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
-                {
+                            string v10 = Marshal.PtrToStringAnsi(data);
-                    Console.WriteLine(builder.ToString());
+                            builder.Append(v10);
-                }
+                            break;
-                builder.Clear();
+                    }
-            }
+                }
-
+                builder.Append("---");
-            if (TDengine.ErrorNo(res) != 0)
+
-            {
+                if (queryRows <= 10)
-                Console.Write("Query is not complete, Error {0:G}", TDengine.ErrorNo(res), TDengine.Error(res));
+                {
-            }
+                    Console.WriteLine(builder.ToString());
-
+                }
-            TDengine.FreeResult(res);
+                builder.Clear();
-
+            }
-        }
+
-
+            if (TDengine.ErrorNo(res) != 0)
-        public void CloseConnection()
+            {
-        {
+                Console.Write("Query is not complete, Error {0:G}", TDengine.ErrorNo(res), TDengine.Error(res));
-            if (this.conn != IntPtr.Zero)
+            }
-            {
+            Console.WriteLine("");
-                TDengine.Close(this.conn);
+
-                Console.WriteLine("connection closed.");
+            TDengine.FreeResult(res);
-            }
+
-        }
+        }
-
+
-        static void ExitProgram()
+        public void CloseConnection()
-        {
+        {
-            TDengine.Cleanup();
+            if (this.conn != IntPtr.Zero)
-            System.Environment.Exit(0);
+            {
-        }
+                TDengine.Close(this.conn);
+                Console.WriteLine("connection closed.");
+            }
+        }
+
+        static void ExitProgram()
+        {
+            TDengine.Cleanup();
+            System.Environment.Exit(0);
+        }
     }
 }

tests/examples/C#/TDengineDriver.cs

@@ -19,136 +19,149 @@ using System.Runtime.InteropServices;
 
 namespace TDengineDriver
 {
-  enum TDengineDataType {
+    enum TDengineDataType
-    TSDB_DATA_TYPE_NULL = 0,     // 1 bytes
-    TSDB_DATA_TYPE_BOOL = 1,     // 1 bytes
-    TSDB_DATA_TYPE_TINYINT = 2,  // 1 bytes
-    TSDB_DATA_TYPE_SMALLINT = 3, // 2 bytes
-    TSDB_DATA_TYPE_INT = 4,      // 4 bytes
-    TSDB_DATA_TYPE_BIGINT = 5,   // 8 bytes
-    TSDB_DATA_TYPE_FLOAT = 6,    // 4 bytes
-    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
-  }
-
-  enum TDengineInitOption
-  {
-    TSDB_OPTION_LOCALE = 0,
-    TSDB_OPTION_CHARSET = 1,
-    TSDB_OPTION_TIMEZONE = 2,
-    TDDB_OPTION_CONFIGDIR = 3,
-    TDDB_OPTION_SHELL_ACTIVITY_TIMER = 4
-  }
-
-  class TDengineMeta
-  {
-    public string name;
-    public short size;
-    public byte type;
-    public string TypeName()
     {
-      switch ((TDengineDataType)type)
+        TSDB_DATA_TYPE_NULL = 0,     // 1 bytes
-      {
+        TSDB_DATA_TYPE_BOOL = 1,     // 1 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_BOOL:
+        TSDB_DATA_TYPE_TINYINT = 2,  // 1 bytes
-          return "BOOLEAN";
+        TSDB_DATA_TYPE_SMALLINT = 3, // 2 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
+        TSDB_DATA_TYPE_INT = 4,      // 4 bytes
-          return "BYTE";
+        TSDB_DATA_TYPE_BIGINT = 5,   // 8 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
+        TSDB_DATA_TYPE_FLOAT = 6,    // 4 bytes
-          return "SHORT";
+        TSDB_DATA_TYPE_DOUBLE = 7,   // 8 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_INT:
+        TSDB_DATA_TYPE_BINARY = 8,   // string
-          return "INT";
+        TSDB_DATA_TYPE_TIMESTAMP = 9,// 8 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
+        TSDB_DATA_TYPE_NCHAR = 10,   // unicode string
-          return "LONG";
+        TSDB_DATA_TYPE_UTINYINT = 11,// 1 byte
-        case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
+        TSDB_DATA_TYPE_USMALLINT= 12,// 2 bytes
-          return "FLOAT";
+        TSDB_DATA_TYPE_UINT = 13,    // 4 bytes
-        case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
+        TSDB_DATA_TYPE_UBIGINT= 14   // 8 bytes
-          return "DOUBLE";
-        case TDengineDataType.TSDB_DATA_TYPE_BINARY:
-          return "STRING";
-        case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
-          return "TIMESTAMP";
-        case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
-          return "NCHAR";
-        default:
-          return "undefine";
-      }
-    }
-  }
-
-  class TDengine
-  {
-    public const int TSDB_CODE_SUCCESS = 0;
-
-    [DllImport("taos.dll", EntryPoint = "taos_init", CallingConvention = CallingConvention.Cdecl)]
-    static extern public void Init();
-
-    [DllImport("taos.dll", EntryPoint = "taos_cleanup", CallingConvention = CallingConvention.Cdecl)]
-    static extern public void Cleanup();
-
-    [DllImport("taos.dll", EntryPoint = "taos_options", CallingConvention = CallingConvention.Cdecl)]
-    static extern public void Options(int option, string value);
-
-    [DllImport("taos.dll", EntryPoint = "taos_connect", CallingConvention = CallingConvention.Cdecl)]
-    static extern public IntPtr Connect(string ip, string user, string password, string db, short port);
-
-    [DllImport("taos.dll", EntryPoint = "taos_errstr", CallingConvention = CallingConvention.Cdecl)]
-    static extern private IntPtr taos_errstr(IntPtr res);
-    static public string Error(IntPtr res)
-    {
-      IntPtr errPtr = taos_errstr(res);
-      return Marshal.PtrToStringAnsi(errPtr);
     }
 
-    [DllImport("taos.dll", EntryPoint = "taos_errno", CallingConvention = CallingConvention.Cdecl)]
+    enum TDengineInitOption
-    static extern public int ErrorNo(IntPtr res);
-
-    [DllImport("taos.dll", EntryPoint = "taos_query", CallingConvention = CallingConvention.Cdecl)]
-    static extern public IntPtr Query(IntPtr conn, string sqlstr);
-
-    [DllImport("taos.dll", EntryPoint = "taos_affected_rows", CallingConvention = CallingConvention.Cdecl)]
-    static extern public int AffectRows(IntPtr res);
-
-    [DllImport("taos.dll", EntryPoint = "taos_field_count", CallingConvention = CallingConvention.Cdecl)]
-    static extern public int FieldCount(IntPtr res);
-
-    [DllImport("taos.dll", EntryPoint = "taos_fetch_fields", CallingConvention = CallingConvention.Cdecl)]
-    static extern private IntPtr taos_fetch_fields(IntPtr res);
-    static public List<TDengineMeta> FetchFields(IntPtr res)
     {
-      const int fieldSize = 68;
+        TSDB_OPTION_LOCALE = 0,
-
+        TSDB_OPTION_CHARSET = 1,
-      List<TDengineMeta> metas = new List<TDengineMeta>();
+        TSDB_OPTION_TIMEZONE = 2,
-      if (res == IntPtr.Zero)
+        TDDB_OPTION_CONFIGDIR = 3,
-      {
+        TDDB_OPTION_SHELL_ACTIVITY_TIMER = 4
-        return metas;
-      }
-
-      int fieldCount = FieldCount(res);
-      IntPtr fieldsPtr = taos_fetch_fields(res);
-  
-      for (int i = 0; i < fieldCount; ++i)
-      {
-        int offset = i * fieldSize;
-        
-        TDengineMeta meta = new TDengineMeta();
-        meta.name = Marshal.PtrToStringAnsi(fieldsPtr + offset);
-        meta.type = Marshal.ReadByte(fieldsPtr + offset + 65);
-        meta.size = Marshal.ReadInt16(fieldsPtr + offset + 66);
-        metas.Add(meta);
-      }
-
-      return metas;
     }
 
-    [DllImport("taos.dll", EntryPoint = "taos_fetch_row", CallingConvention = CallingConvention.Cdecl)]
+    class TDengineMeta
-    static extern public IntPtr FetchRows(IntPtr res);
+    {
+        public string name;
+        public short size;
+        public byte type;
+        public string TypeName()
+        {
+            switch ((TDengineDataType)type)
+            {
+                case TDengineDataType.TSDB_DATA_TYPE_BOOL:
+                    return "BOOL";
+                case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
+                    return "TINYINT";
+                case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
+                    return "SMALLINT";
+                case TDengineDataType.TSDB_DATA_TYPE_INT:
+                    return "INT";
+                case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
+                    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:
+                    return "DOUBLE";
+                case TDengineDataType.TSDB_DATA_TYPE_BINARY:
+                    return "STRING";
+                case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
+                    return "TIMESTAMP";
+                case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
+                    return "NCHAR";
+                default:
+                    return "undefine";
+            }
+        }
+    }
 
-    [DllImport("taos.dll", EntryPoint = "taos_free_result", CallingConvention = CallingConvention.Cdecl)]
+    class TDengine
-    static extern public IntPtr FreeResult(IntPtr res);
+    {
+        public const int TSDB_CODE_SUCCESS = 0;
 
-    [DllImport("taos.dll", EntryPoint = "taos_close", CallingConvention = CallingConvention.Cdecl)]
+        [DllImport("taos", EntryPoint = "taos_init", CallingConvention = CallingConvention.Cdecl)]
-    static extern public int Close(IntPtr taos);
+        static extern public void Init();
-  }
+
-}
+        [DllImport("taos", EntryPoint = "taos_cleanup", CallingConvention = CallingConvention.Cdecl)]
+        static extern public void Cleanup();
+
+        [DllImport("taos", EntryPoint = "taos_options", CallingConvention = CallingConvention.Cdecl)]
+        static extern public void Options(int option, string value);
+
+        [DllImport("taos", EntryPoint = "taos_connect", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr Connect(string ip, string user, string password, string db, short port);
+
+        [DllImport("taos", EntryPoint = "taos_errstr", CallingConvention = CallingConvention.Cdecl)]
+        static extern private IntPtr taos_errstr(IntPtr res);
+        static public string Error(IntPtr res)
+        {
+            IntPtr errPtr = taos_errstr(res);
+            return Marshal.PtrToStringAnsi(errPtr);
+        }
+
+        [DllImport("taos", EntryPoint = "taos_errno", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int ErrorNo(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_query", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr Query(IntPtr conn, string sqlstr);
+
+        [DllImport("taos", EntryPoint = "taos_affected_rows", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int AffectRows(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_field_count", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int FieldCount(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_fetch_fields", CallingConvention = CallingConvention.Cdecl)]
+        static extern private IntPtr taos_fetch_fields(IntPtr res);
+        static public List<TDengineMeta> FetchFields(IntPtr res)
+        {
+            const int fieldSize = 68;
+
+            List<TDengineMeta> metas = new List<TDengineMeta>();
+            if (res == IntPtr.Zero)
+            {
+                return metas;
+            }
+
+            int fieldCount = FieldCount(res);
+            IntPtr fieldsPtr = taos_fetch_fields(res);
+
+            for (int i = 0; i < fieldCount; ++i)
+            {
+                int offset = i * fieldSize;
+
+                TDengineMeta meta = new TDengineMeta();
+                meta.name = Marshal.PtrToStringAnsi(fieldsPtr + offset);
+                meta.type = Marshal.ReadByte(fieldsPtr + offset + 65);
+                meta.size = Marshal.ReadInt16(fieldsPtr + offset + 66);
+                metas.Add(meta);
+            }
+
+            return metas;
+        }
+
+        [DllImport("taos", EntryPoint = "taos_fetch_row", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr FetchRows(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_free_result", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr FreeResult(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_close", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int Close(IntPtr taos);
+    }
+}

tests/examples/C#/TDengineTest.cs

@@ -165,7 +165,7 @@ namespace TDengineDriver
     public void ReadArgument(String[] argv)
     {
       PrintHelp(argv);
-      host = this.GetArgumentAsString(argv, "-h", "192.168.100.128");
+      host = this.GetArgumentAsString(argv, "-h", "127.0.0.1");
       user = this.GetArgumentAsString(argv, "-u", "root");
       password = this.GetArgumentAsString(argv, "-p", "taosdata");
       dbName = this.GetArgumentAsString(argv, "-d", "db");
@@ -212,42 +212,54 @@ namespace TDengineDriver
       StringBuilder sql = new StringBuilder();
       sql.Append("create database if not exists ").Append(this.dbName);
       IntPtr res = TDengine.Query(this.conn, sql.ToString());
-      if (res != IntPtr.Zero)
+      if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
       {
-        Console.WriteLine(sql.ToString() + " success");
+        Console.Write(sql.ToString() + " failure, ");
+        if (res != IntPtr.Zero) {
+          Console.Write("reason: " + TDengine.Error(res));
+        }
+        Console.WriteLine("");
+        ExitProgram();
       }
       else
       {
-        Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+          Console.WriteLine(sql.ToString() + " success");
-        ExitProgram();
       }
       TDengine.FreeResult(res);
 
       sql.Clear();
       sql.Append("use ").Append(this.dbName);
       res = TDengine.Query(this.conn, sql.ToString());
-      if (res != IntPtr.Zero)
+      if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
       {
-        Console.WriteLine(sql.ToString() + " success");
+        Console.Write(sql.ToString() + " failure, ");
+        if (res != IntPtr.Zero) {
+          Console.Write("reason: " + TDengine.Error(res));
+        }
+        Console.WriteLine("");
+        ExitProgram();
       }
       else
       {
-        Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+          Console.WriteLine(sql.ToString() + " success");
-        ExitProgram();
       }
       TDengine.FreeResult(res);
 
       sql.Clear();
       sql.Append("create table if not exists ").Append(this.stableName).Append("(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 float, v7 double, v8 binary(10), v9 nchar(10)) tags(t1 int)");
       res = TDengine.Query(this.conn, sql.ToString());
-      if (res != IntPtr.Zero)
+      if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
       {
-        Console.WriteLine(sql.ToString() + " success");
+        Console.Write(sql.ToString() + " failure, ");
+        if (res != IntPtr.Zero) {
+          Console.Write("reason: " + TDengine.Error(res));
+        }
+        Console.WriteLine("");
+        ExitProgram();
       }
       else
       {
-        Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+          Console.WriteLine(sql.ToString() + " success");
-        ExitProgram();
       }
       TDengine.FreeResult(res);
 
@@ -257,14 +269,18 @@ namespace TDengineDriver
         sql = sql.Append("create table if not exists ").Append(this.tablePrefix).Append(i)
           .Append(" using ").Append(this.stableName).Append(" tags(").Append(i).Append(")");
         res = TDengine.Query(this.conn, sql.ToString());
-        if (res != IntPtr.Zero)
+        if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
         {
-          Console.WriteLine(sql.ToString() + " success");
+          Console.Write(sql.ToString() + " failure, ");
+          if (res != IntPtr.Zero) {
+            Console.Write("reason: " + TDengine.Error(res));
+          }
+          Console.WriteLine("");
+          ExitProgram();
         }
         else
         {
-          Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+          Console.WriteLine(sql.ToString() + " success");
-          ExitProgram();
         }
         TDengine.FreeResult(res);
       }
@@ -298,9 +314,13 @@ namespace TDengineDriver
                .Append(", 5, 6, 7, 'abc', 'def')");
           }
           IntPtr res = TDengine.Query(this.conn, sql.ToString());
-          if (res == IntPtr.Zero)
+          if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
           {
-            Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+            Console.Write(sql.ToString() + " failure, ");
+            if (res != IntPtr.Zero) {
+              Console.Write("reason: " + TDengine.Error(res));
+            }
+            Console.WriteLine("");
           }
 
           int affectRows = TDengine.AffectRows(res);
@@ -326,16 +346,20 @@ namespace TDengineDriver
 
       System.DateTime start = new System.DateTime();
       long queryRows = 0;
-      
+
       for (int i = 0; i < 1/*this.tableCount*/; ++i)
       {
         String sql = "select * from " + this.dbName + "." + tablePrefix + i;
         Console.WriteLine(sql);
 
         IntPtr res = TDengine.Query(conn, sql);
-        if (res == IntPtr.Zero)
+        if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
         {
-          Console.WriteLine(sql + " failure, reason: " + TDengine.Error(res));
+          Console.Write(sql.ToString() + " failure, ");
+          if (res != IntPtr.Zero) {
+            Console.Write("reason: " + TDengine.Error(res));
+          }
+          Console.WriteLine("");
           ExitProgram();
         }
 
@@ -410,6 +434,22 @@ namespace TDengineDriver
                 string v10 = Marshal.PtrToStringAnsi(data);
                 builder.Append(v10);
                 break;
+              case TDengineDataType.TSDB_DATA_TYPE_UTINYINT:
+                  byte v11 = Marshal.ReadByte(data);
+                  builder.Append(v11);
+                  break;
+              case TDengineDataType.TSDB_DATA_TYPE_USMALLINT:
+                  ushort v12 = (ushort)Marshal.ReadInt16(data);
+                  builder.Append(v12);
+                  break;
+              case TDengineDataType.TSDB_DATA_TYPE_UINT:
+                  uint v13 = (uint)Marshal.ReadInt32(data);
+                  builder.Append(v13);
+                  break;
+              case TDengineDataType.TSDB_DATA_TYPE_UBIGINT:
+                  ulong v14 = (ulong)Marshal.ReadInt64(data);
+                  builder.Append(v14);
+                  break;
             }
           }
           builder.Append("---");
@@ -423,8 +463,10 @@ namespace TDengineDriver
 
         if (TDengine.ErrorNo(res) != 0)
         {
-          Console.Write("Query is not complete, Error {0:G}", TDengine.ErrorNo(res), TDengine.Error(res));
+          Console.Write("Query is not complete, Error {0:G}",
+              TDengine.ErrorNo(res), TDengine.Error(res));
         }
+        Console.WriteLine("");
 
         TDengine.FreeResult(res);
       }

tests/examples/C#/taosdemo/taosdemo.cs

@@ -370,16 +370,19 @@ namespace TDengineDriver
             StringBuilder sql = new StringBuilder();
             sql.Append("DROP DATABASE IF EXISTS ").Append(this.dbName);
             IntPtr res = TDengine.Query(this.conn, sql.ToString());
-            if (res != IntPtr.Zero)
+            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
             {
-                VerbosePrint(sql.ToString() + " success\n");
+                Console.Write(sql.ToString() + " failure, ");
+                if (res != IntPtr.Zero) {
+                  Console.Write("reason: " + TDengine.Error(res));
+                }
+                Console.WriteLine("");
+                CleanAndExitProgram(1);
             }
             else
             {
-                Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+                VerbosePrint(sql.ToString() + " success\n");
-                CleanAndExitProgram(1);
             }
-
         }
 
         public void CreateDb()
@@ -387,14 +390,18 @@ namespace TDengineDriver
             StringBuilder sql = new StringBuilder();
             sql.Append("CREATE DATABASE IF NOT EXISTS ").Append(this.dbName).Append(" replica ").Append(this.replica).Append(" keep 36500");
             IntPtr res = TDengine.Query(this.conn, sql.ToString());
-            if (res != IntPtr.Zero)
+            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
             {
-                VerbosePrint(sql.ToString() + " success\n");
+                Console.Write(sql.ToString() + " failure, ");
+                if (res != IntPtr.Zero) {
+                  Console.Write("reason: " + TDengine.Error(res));
+                }
+                Console.WriteLine("");
+                CleanAndExitProgram(1);
             }
             else
             {
-                Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+                VerbosePrint(sql.ToString() + " success\n");
-                CleanAndExitProgram(1);
             }
             TDengine.FreeResult(res);
         }
@@ -408,14 +415,18 @@ namespace TDengineDriver
                 Append(this.dbName).Append(".").Append(this.stablePrefix).
                 Append("(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 float, v7 double, v8 binary(10), v9 nchar(10), v10 tinyint unsigned, v11 smallint unsigned, v12 int unsigned, v13 bigint unsigned) tags(t1 int)");
             IntPtr res = TDengine.Query(this.conn, sql.ToString());
-            if (res != IntPtr.Zero)
+            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
             {
-                VerbosePrint(sql.ToString() + " success\n");
+                Console.Write(sql.ToString() + " failure, ");
+                if (res != IntPtr.Zero) {
+                  Console.Write("reason: " + TDengine.Error(res));
+                }
+                Console.WriteLine("");
+                CleanAndExitProgram(1);
             }
             else
             {
-                Console.WriteLine(sql.ToString() + " failure, reason: " + TDengine.Error(res));
+                VerbosePrint(sql.ToString() + " success\n");
-                CleanAndExitProgram(1);
             }
             TDengine.FreeResult(res);
         }
@@ -495,9 +506,13 @@ namespace TDengineDriver
 
                 IntPtr res = TDengine.Query(conn, sql);
                 DebugPrintFormat("res: {0}\n", res);
-                if (res == IntPtr.Zero)
+                if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
                 {
-                    Console.WriteLine(sql + " failure, reason: " + TDengine.Error(res));
+                    Console.Write(sql.ToString() + " failure, ");
+                    if (res != IntPtr.Zero) {
+                      Console.Write("reason: " + TDengine.Error(res));
+                    }
+                    Console.WriteLine("");
                     CleanAndExitProgram(1);
                 }
 
@@ -782,9 +797,13 @@ namespace TDengineDriver
                         }
                         VerbosePrint(sql.ToString() + "\n");
                         IntPtr res = TDengine.Query(this.conn, sql.ToString());
-                        if (res == IntPtr.Zero)
+                        if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
                         {
-                            VerbosePrint(sql.ToString() + " failure, reason: " + TDengine.Error(res) + "\n");
+                            Console.Write(sql.ToString() + " failure, ");
+                            if (res != IntPtr.Zero) {
+                              Console.Write("reason: " + TDengine.Error(res));
+                            }
+                            Console.WriteLine("");
                         }
 
                         inserted += this.batchRows;
@@ -861,14 +880,18 @@ namespace TDengineDriver
                         sql = sql.Append("(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 float, v7 double, v8 binary(10), v9 nchar(10), v10 tinyint unsigned, v11 smallint unsigned, v12 int unsigned, v13 bigint unsigned)");
                     }
                     IntPtr res = TDengine.Query(this.conn, sql.ToString());
-                    if (res != IntPtr.Zero)
+                    if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
                     {
-                        VerbosePrint(sql.ToString() + " success\n");
+                        Console.Write(sql.ToString() + " failure, ");
+                        if (res != IntPtr.Zero) {
+                          Console.Write("reason: " + TDengine.Error(res));
+                        }
+                        Console.WriteLine("");
+                        CleanAndExitProgram(1);
                     }
                     else
                     {
-                        VerbosePrint(sql.ToString() + " failure, reason: " + TDengine.Error(res) + "\n");
+                        VerbosePrint(sql.ToString() + " success\n");
-                        CleanAndExitProgram(1);
                     }
                     TDengine.FreeResult(res);
                 }

tests/examples/JDBC/springbootdemo/pom.xml

@@ -63,9 +63,9 @@
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>2.0.20</version>
+            <version>2.0.28</version>
 <!--            <scope>system</scope>-->
-<!--            <systemPath>${project.basedir}/src/main/resources/taos-jdbcdriver-2.0.20-dist.jar</systemPath>-->
+<!--            <systemPath>${project.basedir}/src/main/resources/taos-jdbcdriver-2.0.28-dist.jar</systemPath>-->
         </dependency>
 
         <dependency>

tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java

@@ -7,6 +7,7 @@ import org.springframework.boot.autoconfigure.SpringBootApplication;
 @MapperScan(basePackages = {"com.taosdata.example.springbootdemo.dao"})
 @SpringBootApplication
 public class SpringbootdemoApplication {
+
     public static void main(String[] args) {
         SpringApplication.run(SpringbootdemoApplication.class, args);
     }

tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java

@@ -45,7 +45,7 @@ public class WeatherController {
      * @return
      */
     @PostMapping("/{temperature}/{humidity}")
-    public int saveWeather(@PathVariable float temperature, @PathVariable int humidity) {
+    public int saveWeather(@PathVariable float temperature, @PathVariable float humidity) {
         return weatherService.save(temperature, humidity);
     }
 

tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java

@@ -8,8 +8,8 @@ public class Weather {
 
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS", timezone = "GMT+8")
     private Timestamp ts;
-    private float temperature;
+    private Float temperature;
-    private float humidity;
+    private Float humidity;
     private String location;
     private int groupId;
 
@@ -30,19 +30,19 @@ public class Weather {
         this.ts = ts;
     }
 
-    public float getTemperature() {
+    public Float getTemperature() {
         return temperature;
     }
 
-    public void setTemperature(float temperature) {
+    public void setTemperature(Float temperature) {
         this.temperature = temperature;
     }
 
-    public float getHumidity() {
+    public Float getHumidity() {
         return humidity;
     }
 
-    public void setHumidity(float humidity) {
+    public void setHumidity(Float humidity) {
         this.humidity = humidity;
     }
 

tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java

@@ -39,7 +39,7 @@ public class WeatherService {
         return weatherMapper.select(limit, offset);
     }
 
-    public int save(float temperature, int humidity) {
+    public int save(float temperature, float humidity) {
         Weather weather = new Weather();
         weather.setTemperature(temperature);
         weather.setHumidity(humidity);

tests/examples/c/apitest.c

@@ -435,11 +435,15 @@ void verify_async(TAOS* taos) {
 }
 
 void stream_callback(void *param, TAOS_RES *res, TAOS_ROW row) {
+  if (res == NULL || row == NULL) {
+    return;
+  }
+  
   int         num_fields = taos_num_fields(res);
   TAOS_FIELD* fields = taos_fetch_fields(res);
 
   printf("got one row from stream_callback\n");
-  char temp[256];
+  char temp[256] = {0};
   taos_print_row(temp, row, fields, num_fields);
   puts(temp);
 }

tests/examples/go/taosdemo.go

@@ -18,6 +18,7 @@ import (
 	"database/sql"
 	"flag"
 	"fmt"
+	"log"
 	"math/rand"
 	"os"
 	"runtime"
@@ -26,8 +27,6 @@ import (
 	"time"
 
 	_ "github.com/taosdata/driver-go/taosSql"
-
-	//"golang.org/x/sys/unix"
 )
 
 const (
@@ -48,6 +47,7 @@ type config struct {
 	dbName               string
 	supTblName           string
 	tablePrefix          string
+	mode                 string
 	numOftables          int
 	numOfRecordsPerTable int
 	numOfRecordsPerReq   int
@@ -70,6 +70,7 @@ func init() {
 	flag.StringVar(&configPara.password, "P", "taosdata", "The password to use when connecting to the server.")
 	flag.StringVar(&configPara.dbName, "d", "test", "Destination database.")
 	flag.StringVar(&configPara.tablePrefix, "m", "d", "Table prefix name.")
+	flag.StringVar(&configPara.mode, "M", "r", "mode,r:raw,s:stmt")
 	flag.IntVar(&configPara.numOftables, "t", 2, "The number of tables.")
 	flag.IntVar(&configPara.numOfRecordsPerTable, "n", 10, "The number of records per table.")
 	flag.IntVar(&configPara.numOfRecordsPerReq, "r", 3, "The number of records per request.")
@@ -94,6 +95,7 @@ func printAllArgs() {
 	fmt.Printf("usr:                  %v\n", configPara.user)
 	fmt.Printf("password:             %v\n", configPara.password)
 	fmt.Printf("dbName:               %v\n", configPara.dbName)
+	fmt.Printf("mode:                 %v\n", configPara.mode)
 	fmt.Printf("tablePrefix:          %v\n", configPara.tablePrefix)
 	fmt.Printf("numOftables:          %v\n", configPara.numOftables)
 	fmt.Printf("numOfRecordsPerTable: %v\n", configPara.numOfRecordsPerTable)
@@ -119,6 +121,24 @@ func main() {
 	//defer db.Close()
 	rand.Seed(time.Now().Unix())
 
+	if configPara.mode == "s" {
+		fmt.Printf("\n======== start stmt mode test ========\n")
+		db, err := sql.Open("taosSql", url)
+		if err != nil {
+			log.Fatalf("Open database error: %s\n", err)
+		}
+		defer db.Close()
+		demodbStmt := configPara.dbName
+		demotStmt := "demotStmt"
+		drop_database_stmt(db, demodbStmt)
+		create_database_stmt(db, demodbStmt)
+		use_database_stmt(db, demodbStmt)
+		create_table_stmt(db, demotStmt)
+		insert_data_stmt(db, demotStmt)
+		select_data_stmt(db, demotStmt)
+		return
+	}
+
 	createDatabase(configPara.dbName, configPara.supTblName)
 	fmt.Printf("======== create database success! ========\n\n")
 
@@ -407,6 +427,132 @@ func selectTest(dbName string, tbPrefix string, supTblName string) {
 		checkErr(err, "rows next iteration error")
 	}
 }
+func drop_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// drop test db
+	res, err := db.Exec("drop database if exists " + demodb)
+	checkErr(err, "drop database "+demodb)
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "drop db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("drop database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// create database
+	//var stmt interface{}
+	stmt, err := db.Prepare("create database ?")
+	checkErr(err, "create db, db.Prepare")
+
+	//var res driver.Result
+	res, err := stmt.Exec(demodb)
+	checkErr(err, "create db, stmt.Exec")
+
+	//fmt.Printf("Query OK, %d row(s) affected()", res.RowsAffected())
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("create database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func use_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// create database
+	//var stmt interface{}
+	stmt, err := db.Prepare("use " + demodb)
+	checkErr(err, "use db, db.Prepare")
+
+	res, err := stmt.Exec()
+	checkErr(err, "use db, stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "use db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("use database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_table_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// create table
+	// (ts timestamp, id int, name binary(8), len tinyint, flag bool, notes binary(8), fv float, dv double)
+	stmt, err := db.Prepare("create table ? (? timestamp, ? int, ? binary(10), ? tinyint, ? bool, ? binary(8), ? float, ? double)")
+	checkErr(err, "create table db.Prepare")
+
+	res, err := stmt.Exec(demot, "ts", "id", "name", "len", "flag", "notes", "fv", "dv")
+	checkErr(err, "create table stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create table res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("create table result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func insert_data_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// insert data into table
+	stmt, err := db.Prepare("insert into ? values(?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?)")
+	checkErr(err, "insert db.Prepare")
+
+	res, err := stmt.Exec(demot, "now", 1000, "'haidian'", 6, true, "'AI world'", 6987.654, 321.987,
+		"now+1s", 1001, "'changyang'", 7, false, "'DeepMode'", 12356.456, 128634.456,
+		"now+2s", 1002, "'chuangping'", 8, true, "'database'", 3879.456, 65433478.456)
+	checkErr(err, "insert data, stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func select_data_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+
+	stmt, err := db.Prepare("select ?, ?, ?, ?, ?, ?, ?, ? from ?") // go binary mode
+	checkErr(err, "db.Prepare")
+
+	rows, err := stmt.Query("ts", "id", "name", "len", "flag", "notes", "fv", "dv", demot)
+	checkErr(err, "stmt.Query")
+
+	fmt.Printf("%10s%s%8s %5s %8s%s %s %10s%s %7s%s %8s%s %11s%s %14s%s\n", " ", "ts", " ", "id", " ", "name", " ", "len", " ", "flag", " ", "notes", " ", "fv", " ", " ", "dv")
+	var affectd int
+	for rows.Next() {
+		var ts string
+		var name string
+		var id int
+		var len int8
+		var flag bool
+		var notes string
+		var fv float32
+		var dv float64
+
+		err = rows.Scan(&ts, &id, &name, &len, &flag, &notes, &fv, &dv)
+		//fmt.Println("start scan fields from row.rs, &fv:", &fv)
+		//err = rows.Scan(&fv)
+		checkErr(err, "rows.Scan")
+
+		fmt.Printf("%s\t", ts)
+		fmt.Printf("%d\t", id)
+		fmt.Printf("%10s\t", name)
+		fmt.Printf("%d\t", len)
+		fmt.Printf("%t\t", flag)
+		fmt.Printf("%s\t", notes)
+		fmt.Printf("%06.3f\t", fv)
+		fmt.Printf("%09.6f\n", dv)
+
+		affectd++
+
+	}
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
 func checkErr(err error, prompt string) {
 	if err != nil {
 		fmt.Printf("%s\n", prompt)

tests/perftest-scripts/perftest-query.sh

@@ -64,7 +64,7 @@ function runQueryPerfTest {
 	[ -f $PERFORMANCE_TEST_REPORT ] && rm $PERFORMANCE_TEST_REPORT
 	nohup $WORK_DIR/TDengine/debug/build/bin/taosd -c /etc/taosperf/ > /dev/null 2>&1 &
 	echoInfo "Wait TDengine to start"
-	sleep 120
+	sleep 300
 	echoInfo "Run Performance Test"	
 	cd $WORK_DIR/TDengine/tests/pytest
 	

tests/pytest/alter/alterTabAddTagWithNULL.py

@@ -0,0 +1,85 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to execute {__file__}")
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database  if not exists db keep 36500")
+        tdSql.execute("use db")
+
+        tdLog.printNoPrefix("==========step1:create table && insert data")
+        tdSql.execute("create table stbtag (ts timestamp, c1 int) TAGS(t1 int)")
+        tdSql.execute("create table tag1 using stbtag tags(1)")
+
+        tdLog.printNoPrefix("==========step2:alter stb add tag create new chiltable")
+        tdSql.execute("alter table stbtag add tag t2 int")
+        tdSql.execute("alter table stbtag add tag t3 tinyint")
+        tdSql.execute("alter table stbtag add tag t4 smallint ")
+        tdSql.execute("alter table stbtag add tag t5 bigint")
+        tdSql.execute("alter table stbtag add tag t6 float ")
+        tdSql.execute("alter table stbtag add tag t7 double ")
+        tdSql.execute("alter table stbtag add tag t8 bool ")
+        tdSql.execute("alter table stbtag add tag t9 binary(10) ")
+        tdSql.execute("alter table stbtag add tag t10 nchar(10)")
+
+        tdSql.execute("create table tag2 using stbtag tags(2, 22, 23, 24, 25, 26.1, 27.1, 1, 'binary9', 'nchar10')")
+        tdSql.query( "select tbname, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 from stbtag" )
+        tdSql.checkData(1, 0, "tag2")
+        tdSql.checkData(1, 1, 2)
+        tdSql.checkData(1, 2, 22)
+        tdSql.checkData(1, 3, 23)
+        tdSql.checkData(1, 4, 24)
+        tdSql.checkData(1, 5, 25)
+        tdSql.checkData(1, 6, 26.1)
+        tdSql.checkData(1, 7, 27.1)
+        tdSql.checkData(1, 8, 1)
+        tdSql.checkData(1, 9, "binary9")
+        tdSql.checkData(1, 10, "nchar10")
+
+        tdLog.printNoPrefix("==========step3:alter stb drop tag create new chiltable")
+        tdSql.execute("alter table stbtag drop tag t2 ")
+        tdSql.execute("alter table stbtag drop tag t3 ")
+        tdSql.execute("alter table stbtag drop tag t4 ")
+        tdSql.execute("alter table stbtag drop tag t5 ")
+        tdSql.execute("alter table stbtag drop tag t6 ")
+        tdSql.execute("alter table stbtag drop tag t7 ")
+        tdSql.execute("alter table stbtag drop tag t8 ")
+        tdSql.execute("alter table stbtag drop tag t9 ")
+        tdSql.execute("alter table stbtag drop tag t10 ")
+
+        tdSql.execute("create table tag3 using stbtag tags(3)")
+        tdSql.query("select * from stbtag where tbname like 'tag3' ")
+        tdSql.checkCols(3)
+        tdSql.query("select tbname, t1 from stbtag where tbname like 'tag3' ")
+        tdSql.checkData(0, 1, 3)
+
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/alter/alterTimestampColDataProcess.py

@@ -0,0 +1,73 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to execute {__file__}")
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database  if not exists db keep 36500")
+        tdSql.execute("use db")
+
+        tdLog.printNoPrefix("==========step1:create table && insert data")
+        # timestamp list:
+        #   0 -> "1970-01-01 08:00:00" | -28800000 -> "1970-01-01 00:00:00" | -946800000000 -> "1940-01-01 00:00:00"
+        #   -631180800000 -> "1950-01-01 00:00:00"
+        ts1 = 0
+        ts2 = -28800000
+        ts3 = -946800000000
+        ts4 = "1950-01-01 00:00:00"
+        tdSql.execute(
+            "create table stb2ts (ts timestamp, ts1 timestamp, ts2 timestamp, c1 int, ts3 timestamp) TAGS(t1 int)"
+        )
+        tdSql.execute("create table t2ts1 using stb2ts tags(1)")
+
+        tdSql.execute(f"insert into t2ts1 values ({ts1}, {ts1}, {ts1}, 1, {ts1})")
+        tdSql.execute(f"insert into t2ts1 values ({ts2}, {ts2}, {ts2}, 2, {ts2})")
+        tdSql.execute(f"insert into t2ts1 values ({ts3}, {ts3}, {ts3}, 4, {ts3})")
+        tdSql.execute(f"insert into t2ts1 values ('{ts4}', '{ts4}', '{ts4}', 3, '{ts4}')")
+
+        tdLog.printNoPrefix("==========step2:check inserted data")
+        tdSql.query("select * from stb2ts where ts1=0 and ts2='1970-01-01 08:00:00' ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 4,'1970-01-01 08:00:00')
+
+        tdSql.query("select * from stb2ts where ts1=-28800000 and ts2='1970-01-01 00:00:00' ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 4, '1970-01-01 00:00:00')
+
+        tdSql.query("select * from stb2ts where ts1=-946800000000 and ts2='1940-01-01 00:00:00' ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 4, '1940-01-01 00:00:00')
+
+        tdSql.query("select * from stb2ts where ts1=-631180800000 and ts2='1950-01-01 00:00:00' ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 4, '1950-01-01 00:00:00')
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/fulltest.sh

@@ -219,6 +219,10 @@ python3 ./test.py -f query/bug3351.py
 python3 ./test.py -f query/bug3375.py
 python3 ./test.py -f query/queryJoin10tables.py
 python3 ./test.py -f query/queryStddevWithGroupby.py
+python3 ./test.py -f query/querySecondtscolumnTowherenow.py
+python3 ./test.py -f query/queryFilterTswithDateUnit.py
+
+
 
 #stream
 python3 ./test.py -f stream/metric_1.py
@@ -234,6 +238,8 @@ python3 ./test.py -f stream/table_n.py
 
 #alter table
 python3 ./test.py -f alter/alter_table_crash.py
+python3 ./test.py -f alter/alterTabAddTagWithNULL.py
+python3 ./test.py -f alter/alterTimestampColDataProcess.py
 
 # client
 python3 ./test.py -f client/client.py
@@ -303,6 +309,11 @@ python3 ./test.py -f insert/unsignedSmallint.py
 python3 ./test.py -f insert/unsignedTinyint.py
 python3 ./test.py -f query/filterAllUnsignedIntTypes.py
 
+python3 ./test.py -f tag_lite/unsignedInt.py
+python3 ./test.py -f tag_lite/unsignedBigint.py
+python3 ./test.py -f tag_lite/unsignedSmallint.py
+python3 ./test.py -f tag_lite/unsignedTinyint.py
+
 python3 ./test.py -f functions/function_percentile2.py
 python3 ./test.py -f insert/boundary2.py
 python3 ./test.py -f alter/alter_debugFlag.py

tests/pytest/query/queryFilterTswithDateUnit.py

@@ -0,0 +1,166 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to execute {__file__}")
+        tdSql.init(conn.cursor(), logSql)
+
+    def insertnow(self, tsp1, tsp2, tsp3):
+
+        tdSql.execute(
+            "create table stbts (ts timestamp, ts1 timestamp, c1 int, ts2 timestamp) TAGS(t1 int)"
+        )
+        tdSql.execute("create table tts1 using stbts tags(1)")
+
+        tdSql.execute("insert into tts1 values (now+1d, now+1d, 6, now+1d)")
+        tdSql.execute("insert into tts1 values (now, now, 5, now)")
+        tdSql.execute("insert into tts1 values (now-1d, now-1d, 4, now-1d)")
+        tdSql.execute(f"insert into tts1 values ({tsp1}, {tsp1}, 3, {tsp1})")
+        tdSql.execute(f"insert into tts1 values ({tsp2}, {tsp2}, 2, {tsp2})")
+        tdSql.execute(f"insert into tts1 values ({tsp3}, {tsp3}, 1, {tsp3})")
+
+
+    def querynow(self):
+
+        tdLog.printNoPrefix("==========step query: execute query operation")
+        time.sleep(1)
+
+        cols = ["ts", "ts1", "ts2"]
+
+        for col in cols:
+            tdSql.error(f" select * from tts1 where {col} = 1d ")
+            tdSql.error(f" select * from tts1 where {col} < 1d ")
+            tdSql.error(f" select * from tts1 where {col} > 1d ")
+            tdSql.error(f" select * from tts1 where {col} >= 1d ")
+            tdSql.error(f" select * from tts1 where {col} <= 1d ")
+            tdSql.error(f" select * from tts1 where {col} <> 1d ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1m ")
+            tdSql.error(f" select * from tts1 where {col} < 1m ")
+            tdSql.error(f" select * from tts1 where {col} > 1m ")
+            tdSql.error(f" select * from tts1 where {col} >= 1m ")
+            tdSql.error(f" select * from tts1 where {col} <= 1m ")
+            tdSql.error(f" select * from tts1 where {col} <> 1m ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1s ")
+            tdSql.error(f" select * from tts1 where {col} < 1s ")
+            tdSql.error(f" select * from tts1 where {col} > 1s ")
+            tdSql.error(f" select * from tts1 where {col} >= 1s ")
+            tdSql.error(f" select * from tts1 where {col} <= 1s ")
+            tdSql.error(f" select * from tts1 where {col} <> 1s ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1a ")
+            tdSql.error(f" select * from tts1 where {col} < 1a ")
+            tdSql.error(f" select * from tts1 where {col} > 1a ")
+            tdSql.error(f" select * from tts1 where {col} >= 1a ")
+            tdSql.error(f" select * from tts1 where {col} <= 1a ")
+            tdSql.error(f" select * from tts1 where {col} <> 1a ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1h ")
+            tdSql.error(f" select * from tts1 where {col} < 1h ")
+            tdSql.error(f" select * from tts1 where {col} > 1h ")
+            tdSql.error(f" select * from tts1 where {col} >= 1h ")
+            tdSql.error(f" select * from tts1 where {col} <= 1h ")
+            tdSql.error(f" select * from tts1 where {col} <> 1h ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1w ")
+            tdSql.error(f" select * from tts1 where {col} < 1w ")
+            tdSql.error(f" select * from tts1 where {col} > 1w ")
+            tdSql.error(f" select * from tts1 where {col} >= 1w ")
+            tdSql.error(f" select * from tts1 where {col} <= 1w ")
+            tdSql.error(f" select * from tts1 where {col} <> 1w ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1u ")
+            tdSql.error(f" select * from tts1 where {col} < 1u ")
+            tdSql.error(f" select * from tts1 where {col} > 1u ")
+            tdSql.error(f" select * from tts1 where {col} >= 1u ")
+            tdSql.error(f" select * from tts1 where {col} <= 1u ")
+            tdSql.error(f" select * from tts1 where {col} <> 1u ")
+
+            tdSql.error(f" select * from tts1 where {col} = 0d ")
+            tdSql.error(f" select * from tts1 where {col} < 0s ")
+            tdSql.error(f" select * from tts1 where {col} > 0a ")
+            tdSql.error(f" select * from tts1 where {col} >= 0m ")
+            tdSql.error(f" select * from tts1 where {col} <= 0h ")
+            tdSql.error(f" select * from tts1 where {col} <> 0u ")
+            tdSql.error(f" select * from tts1 where {col} <> 0w ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1m+1h ")
+            tdSql.error(f" select * from tts1 where {col} < 1w-1d ")
+            tdSql.error(f" select * from tts1 where {col} > 0a/1u ")
+            tdSql.error(f" select * from tts1 where {col} >= 1d/0s ")
+            tdSql.error(f" select * from tts1 where {col} <= 1s*1a ")
+            tdSql.error(f" select * from tts1 where {col} <> 0w/0d ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1m+1h ")
+            tdSql.error(f" select * from tts1 where {col} < 1w-1d ")
+            tdSql.error(f" select * from tts1 where {col} > 0a/1u ")
+            tdSql.error(f" select * from tts1 where {col} >= 1d/0s ")
+            tdSql.error(f" select * from tts1 where {col} <= 1s*1a ")
+            tdSql.error(f" select * from tts1 where {col} <> 0w/0d ")
+
+            tdSql.error(f" select * from tts1 where {col} = 1u+1 ")
+            tdSql.error(f" select * from tts1 where {col} < 1a-1 ")
+            tdSql.error(f" select * from tts1 where {col} > 1s*1 ")
+            tdSql.error(f" select * from tts1 where {col} >= 1m/1 ")
+            tdSql.error(f" select * from tts1 where {col} <= 1h/0 ")
+            tdSql.error(f" select * from tts1 where {col} <> 0/1d ")
+            tdSql.error(f" select * from tts1 where {col} <> 1w+'2010-01-01 00:00:00' ")
+
+
+    def run(self):
+        tdSql.execute("drop database if exists dbms")
+        tdSql.execute("drop database if exists dbus")
+
+        # timestamp list:
+        #   0 -> "1970-01-01 08:00:00" | -28800000 -> "1970-01-01 00:00:00" | -946800000000 -> "1940-01-01 00:00:00"
+        #   -631180800000 -> "1950-01-01 00:00:00"
+
+        tdLog.printNoPrefix("==========step1:create table precision ms && insert data && query")
+        # create databases precision is ms
+        tdSql.execute("create database  if not exists dbms keep 36500")
+        tdSql.execute("use dbms")
+        tsp1 = 0
+        tsp2 = -28800000
+        tsp3 = -946800000000
+        self.insertnow(tsp1,tsp2,tsp3)
+        self.querynow()
+
+        tdLog.printNoPrefix("==========step2:create table precision us && insert data && query")
+        # create databases precision is us
+        tdSql.execute("create database  if not exists dbus keep 36500 precision 'us' ")
+        tdSql.execute("use dbus")
+        tsp2 = -28800000 * 1000
+        tsp3 = -946800000000 * 1000
+        self.insertnow(tsp1,tsp2,tsp3)
+        self.querynow()
+
+
+
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/queryNormal.py

@@ -16,7 +16,7 @@ import taos
 from util.log import *
 from util.cases import *
 from util.sql import *
-
+from util.dnodes import *
 
 class TDTestCase:
     def init(self, conn, logSql):
@@ -122,6 +122,32 @@ class TDTestCase:
         tdSql.query("SELECT server_status()")
         tdSql.checkRows(1)
 
+         # https://jira.taosdata.com:18080/browse/TD-3800
+        tdSql.execute("create table m1(ts timestamp, k int) tags(a int)")
+        tdSql.execute("create table tm0 using m1 tags(1)")
+        tdSql.execute("create table tm1 using m1 tags(2)")
+        tdSql.execute("insert into tm0 values('2020-3-1 1:1:1', 112)")
+        tdSql.execute("insert into tm1 values('2020-1-1 1:1:1', 1)('2020-3-1 0:1:1', 421)")
+
+        tdSql.query("select last(*) from m1 group by tbname")
+        tdSql.checkData(0, 0, "2020-03-01 01:01:01")
+        tdSql.checkData(0, 1, 112)
+        tdSql.checkData(0, 2, "tm0")
+        tdSql.checkData(1, 0, "2020-03-01 00:01:01")
+        tdSql.checkData(1, 1, 421)
+        tdSql.checkData(1, 2, "tm1")
+        
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+
+        tdSql.query("select last(*) from m1 group by tbname")
+        tdSql.checkData(0, 0, "2020-03-01 01:01:01")
+        tdSql.checkData(0, 1, 112)
+        tdSql.checkData(0, 2, "tm0")
+        tdSql.checkData(1, 0, "2020-03-01 00:01:01")
+        tdSql.checkData(1, 1, 421)
+        tdSql.checkData(1, 2, "tm1")
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/pytest/query/querySecondtscolumnTowherenow.py

@@ -0,0 +1,131 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to execute {__file__}")
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database  if not exists db keep 36500")
+        tdSql.execute("use db")
+
+        tdLog.printNoPrefix("==========step1:create table && insert data")
+        # timestamp list:
+        #   0->"1970-01-01 08:00:00" | -28800000->"1970-01-01 00:00:00" | -946800000000->"1940-01-01 00:00:00"
+        ts1 = 0
+        ts2 = -28800000
+        ts3 = -946800000000
+        tdSql.execute(
+            "create table stb2ts (ts timestamp, ts1 timestamp, ts2 timestamp, c1 int, ts3 timestamp) TAGS(t1 int)"
+        )
+        tdSql.execute("create table t2ts1 using stb2ts tags(1)")
+
+        tdSql.execute("insert into t2ts1 values (now, now, now, 1, now)")
+        tdSql.execute("insert into t2ts1 values (now-1m, now-1m, now-1m, 1, now-1m)")
+        tdSql.execute(f"insert into t2ts1 values ({ts1}, {ts1}, {ts1}, 1, {ts1})")
+        # tdSql.execute(f"insert into t2ts1 values ({ts2}, {ts2}, {ts2}, 1, {ts2})")
+        # tdSql.execute(f"insert into t2ts1 values ({ts3}, {ts3}, {ts3}, 1, {ts3})")
+
+        tdLog.printNoPrefix("==========step2:query")
+        time.sleep(1)
+        # query primary key timestamp column
+        tdSql.execute("select * from t2ts1 where ts < now")
+        ts_len1 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts <= now")
+        ts_len2 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts > now")
+        ts_len3 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts >= now")
+        ts_len4 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts = now")
+        ts_len5 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts <> now")
+        ts_len6 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts between 0 and now")
+        ts_len7 = len(tdSql.cursor.fetchall())
+        tdSql.execute("select * from t2ts1 where ts between now and now+100d")
+        ts_len8 = len(tdSql.cursor.fetchall())
+
+        # query noemal timestamp column
+        tdSql.query("select * from t2ts1 where ts1 < now")
+        tdSql.checkRows(ts_len1)
+        tdSql.query("select * from t2ts1 where ts2 < now")
+        tdSql.checkRows(ts_len1)
+        tdSql.query("select * from t2ts1 where ts3 < now")
+        tdSql.checkRows(ts_len1)
+
+        tdSql.query("select * from t2ts1 where ts1 <= now")
+        tdSql.checkRows(ts_len2)
+        tdSql.query("select * from t2ts1 where ts2 <= now")
+        tdSql.checkRows(ts_len2)
+        tdSql.query("select * from t2ts1 where ts3 <= now")
+        tdSql.checkRows(ts_len2)
+
+        tdSql.query("select * from t2ts1 where ts1 > now")
+        tdSql.checkRows(ts_len3)
+        tdSql.query("select * from t2ts1 where ts2 > now")
+        tdSql.checkRows(ts_len3)
+        tdSql.query("select * from t2ts1 where ts3 > now")
+        tdSql.checkRows(ts_len3)
+
+        tdSql.query("select * from t2ts1 where ts1 >= now")
+        tdSql.checkRows(ts_len4)
+        tdSql.query("select * from t2ts1 where ts2 >= now")
+        tdSql.checkRows(ts_len4)
+        tdSql.query("select * from t2ts1 where ts3 >= now")
+        tdSql.checkRows(ts_len4)
+
+        tdSql.query("select * from t2ts1 where ts1 = now")
+        tdSql.checkRows(ts_len5)
+        tdSql.query("select * from t2ts1 where ts2 = now")
+        tdSql.checkRows(ts_len5)
+        tdSql.query("select * from t2ts1 where ts2 = now")
+        tdSql.checkRows(ts_len5)
+
+        tdSql.query("select * from t2ts1 where ts1 <> now")
+        tdSql.checkRows(ts_len6)
+        tdSql.query("select * from t2ts1 where ts2 <> now")
+        tdSql.checkRows(ts_len6)
+        tdSql.query("select * from t2ts1 where ts3 <> now")
+        tdSql.checkRows(ts_len6)
+
+        tdSql.query("select * from t2ts1 where ts1 between 0 and now")
+        tdSql.checkRows(ts_len7)
+        tdSql.query("select * from t2ts1 where ts2 between 0 and now")
+        tdSql.checkRows(ts_len7)
+        tdSql.query("select * from t2ts1 where ts3 between 0 and now")
+        tdSql.checkRows(ts_len7)
+
+        tdSql.query("select * from t2ts1 where ts1 between now and now+100d")
+        tdSql.checkRows(ts_len8)
+        tdSql.query("select * from t2ts1 where ts2 between now and now+100d")
+        tdSql.checkRows(ts_len8)
+        tdSql.query("select * from t2ts1 where ts3 between now and now+100d")
+        tdSql.checkRows(ts_len8)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())