add the union support in sql parser. #1032. [TBASE-1140]

src/client/inc/tscUtil.h

@@ -29,9 +29,9 @@ extern "C" {
 #include "tsclient.h"
 #include "tsdb.h"
 
-#define UTIL_METER_IS_METRIC(metaInfo) \
+#define UTIL_METER_IS_SUPERTABLE(metaInfo) \
   (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->meterType == TSDB_METER_METRIC))
-#define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_METRIC(metaInfo)))
+#define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_SUPERTABLE(metaInfo)))
 #define UTIL_METER_IS_CREATE_FROM_METRIC(metaInfo) \
   (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->meterType == TSDB_METER_MTABLE))
 
@@ -95,23 +95,23 @@ SMeterSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
  * @param pSql  sql object
  * @return
  */
-bool tscIsPointInterpQuery(SSqlCmd* pCmd);
-bool tscIsTWAQuery(SSqlCmd* pCmd);
-bool tscProjectionQueryOnMetric(SSqlCmd* pCmd);
-bool tscProjectionQueryOnTable(SSqlCmd* pCmd);
+bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
+bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
+bool tscProjectionQueryOnMetric(SSqlCmd* pCmd, int32_t subClauseIndex);
+bool tscProjectionQueryOnTable(SQueryInfo* pQueryInfo);
 
 bool tscIsTwoStageMergeMetricQuery(SSqlCmd* pCmd);
 bool tscQueryOnMetric(SSqlCmd* pCmd);
-bool tscQueryMetricTags(SSqlCmd* pCmd);
+bool tscQueryMetricTags(SQueryInfo* pQueryInfo);
 bool tscIsSelectivityWithTagQuery(SSqlCmd* pCmd);
 
-void tscAddSpecialColumnForSelect(SSqlCmd* pCmd, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
+void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
                                   SSchema* pColSchema, int16_t isTag);
 
-void addRequiredTagColumn(SSqlCmd* pCmd, int32_t tagColIndex, int32_t tableIndex);
+void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
 
-int32_t setMeterID(SSqlObj* pSql, SSQLToken* pzTableName, int32_t tableIndex);
-void    tscClearInterpInfo(SSqlCmd* pCmd);
+int32_t setMeterID(SSqlObj* pSql, int32_t subClauseIndex, SSQLToken* pzTableName, int32_t tableIndex);
+void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertOrImportData(char* sqlstr);
 
@@ -125,30 +125,30 @@ void tscFieldInfoSetValFromField(SFieldInfo* pFieldInfo, int32_t index, TAOS_FIE
 void tscFieldInfoSetValue(SFieldInfo* pFieldInfo, int32_t index, int8_t type, const char* name, int16_t bytes);
 void tscFieldInfoUpdateVisible(SFieldInfo* pFieldInfo, int32_t index, bool visible);
 
-void tscFieldInfoCalOffset(SSqlCmd* pCmd);
-void tscFieldInfoUpdateOffset(SSqlCmd* pCmd);
+void tscFieldInfoCalOffset(SQueryInfo* pQueryInfo);
+void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
 void tscFieldInfoCopy(SFieldInfo* src, SFieldInfo* dst, const int32_t* indexList, int32_t size);
 void tscFieldInfoCopyAll(SFieldInfo* src, SFieldInfo* dst);
 
-TAOS_FIELD* tscFieldInfoGetField(SSqlCmd* pCmd, int32_t index);
-int16_t     tscFieldInfoGetOffset(SSqlCmd* pCmd, int32_t index);
-int32_t     tscGetResRowLength(SSqlCmd* pCmd);
+TAOS_FIELD* tscFieldInfoGetField(SQueryInfo* pQueryInfo, int32_t index);
+int16_t     tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
+int32_t     tscGetResRowLength(SQueryInfo* pQueryInfo);
 void        tscClearFieldInfo(SFieldInfo* pFieldInfo);
-int32_t tscNumOfFields(SSqlCmd* pCmd);
+int32_t tscNumOfFields(SQueryInfo* pQueryInfo);
 
 void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes, int16_t tableIndex);
 
-SSqlExpr* tscSqlExprInsert(SSqlCmd* pCmd, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t interSize);
-SSqlExpr* tscSqlExprInsertEmpty(SSqlCmd* pCmd, int32_t index, int16_t functionId);
+SSqlExpr* tscSqlExprInsertEmpty(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId);
 
-SSqlExpr* tscSqlExprUpdate(SSqlCmd* pCmd, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
+SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
 
-SSqlExpr* tscSqlExprGet(SSqlCmd* pCmd, int32_t index);
+SSqlExpr* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
 void      tscSqlExprCopy(SSqlExprInfo* dst, const SSqlExprInfo* src, uint64_t uid);
 
-SColumnBase* tscColumnBaseInfoInsert(SSqlCmd* pCmd, SColumnIndex* colIndex);
+SColumnBase* tscColumnBaseInfoInsert(SQueryInfo* pQueryInfo, SColumnIndex* colIndex);
 void         tscColumnFilterInfoCopy(SColumnFilterInfo* dst, const SColumnFilterInfo* src);
 void         tscColumnBaseCopy(SColumnBase* dst, const SColumnBase* src);
 
@@ -172,31 +172,36 @@ void   tsSetMetricQueryCond(STagCond* pTagCond, uint64_t uid, const char* str);
 void tscTagCondCopy(STagCond* dest, const STagCond* src);
 void tscTagCondRelease(STagCond* pCond);
 
-void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SSqlCmd* pCmd);
+void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo);
 
 void tscSetFreeHeatBeat(STscObj* pObj);
 bool tscShouldFreeHeatBeat(SSqlObj* pHb);
 void tscCleanSqlCmd(SSqlCmd* pCmd);
 bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql);
 
-void            tscRemoveAllMeterMetaInfo(SSqlCmd* pCmd, bool removeFromCache);
-SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd* pCmd, int32_t index);
-SMeterMetaInfo* tscGetMeterMetaInfoByUid(SSqlCmd* pCmd, uint64_t uid, int32_t* index);
+void            tscRemoveAllMeterMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool removeFromCache);
+SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
+SMeterMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
+
+SQueryInfo *tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex);
+
+SMeterMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, int32_t subClauseIndex, uint64_t uid, int32_t* index);
 void            tscClearMeterMetaInfo(SMeterMetaInfo* pMeterMetaInfo, bool removeFromCache);
 
-SMeterMetaInfo* tscAddMeterMetaInfo(SSqlCmd* pCmd, const char* name, SMeterMeta* pMeterMeta, SMetricMeta* pMetricMeta,
+SMeterMetaInfo* tscAddMeterMetaInfo(SSqlCmd* pCmd, int32_t subClauseIndex, const char* name, SMeterMeta* pMeterMeta, SMetricMeta* pMetricMeta,
                                     int16_t numOfTags, int16_t* tags);
-SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SSqlCmd* pCmd);
-int32_t tscAddQueryInfo(SSqlCmd *pCmd);
+SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SSqlCmd* pCmd, int32_t subClauseIndex);
+int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
+void tscFreeSubqueryInfo(SSqlCmd* pCmd);
 
-void tscGetMetricMetaCacheKey(SSqlCmd* pCmd, char* keyStr, uint64_t uid);
+void tscGetMetricMetaCacheKey(SSqlCmd* pCmd, int32_t subClauseIndex, char* keyStr, uint64_t uid);
 int  tscGetMetricMeta(SSqlObj* pSql);
 int  tscGetMeterMeta(SSqlObj* pSql, char* meterId, int32_t tableIndex);
 int  tscGetMeterMetaEx(SSqlObj* pSql, char* meterId, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
 
-void tscAddTimestampColumn(SSqlCmd* pCmd, int16_t functionId, int16_t tableIndex);
+void tscAddTimestampColumn(SQueryInfo* pQueryInfo, int16_t functionId, int16_t tableIndex);
 void tscDoQuery(SSqlObj* pSql);
 
 /**
@@ -217,9 +222,9 @@ void tscDoQuery(SSqlObj* pSql);
  * @return
  */
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void* param, SSqlObj* pPrevSql);
-void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t tableIndex);
+void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
 
-void doAddGroupColumnForSubquery(SSqlCmd* pCmd, int32_t tagIndex);
+void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);
 
 int16_t tscGetJoinTagColIndexByUid(STagCond* pTagCond, uint64_t uid);
 
@@ -228,7 +233,7 @@ TAOS* taos_connect_a(char* ip, char* user, char* pass, char* db, uint16_t port,
 
 void sortRemoveDuplicates(STableDataBlocks* dataBuf);
 
-void tscPrintSelectClause(SSqlCmd* pCmd);
+void tscPrintSelectClause(SSqlCmd* pCmd, int32_t subClauseIndex);
 
 #ifdef __cplusplus
 }

src/client/inc/tsclient.h

@@ -39,9 +39,9 @@ extern "C" {
 #include "tsqlfunction.h"
 #include "tutil.h"
 
-#define TSC_GET_RESPTR_BASE(res, cmd, col, ord)                     \
-  ((res->data + tscFieldInfoGetOffset(cmd, col) * res->numOfRows) + \
-   (1 - ord.order) * (res->numOfRows - 1) * tscFieldInfoGetField(cmd, col)->bytes)
+#define TSC_GET_RESPTR_BASE(res, _queryinfo, col, ord)                     \
+  ((res->data + tscFieldInfoGetOffset(_queryinfo, col) * res->numOfRows) + \
+   (1 - ord.order) * (res->numOfRows - 1) * tscFieldInfoGetField(_queryinfo, col)->bytes)
 
 // forward declaration
 struct SSqlInfo;
@@ -208,6 +208,7 @@ typedef struct SDataBlockList {
 } SDataBlockList;
 
 typedef struct SQueryInfo {
+  uint16_t        type;  // query type
   char            intervalTimeUnit;
   
   int64_t         etime, stime;
@@ -221,16 +222,18 @@ typedef struct SQueryInfo {
   SLimitVal       limit;
   SLimitVal       slimit;
   STagCond        tagCond;
+  SOrderVal       order;
   int16_t         interpoType;  // interpolate type
   int16_t         numOfTables;
   SMeterMetaInfo **pMeterInfo;
   struct STSBuf *  tsBuf;
   // todo use dynamic allocated memory for defaultVal
   int64_t defaultVal[TSDB_MAX_COLUMNS];  // default value for interpolation
+  char*           msg;       // pointer to the pCmd->payload to keep error message temporarily
 } SQueryInfo;
 
 typedef struct {
-  SOrderVal order;
+//  SOrderVal order;
   int       command;
   int       count;  // TODO refactor
 
@@ -241,7 +244,6 @@ typedef struct {
 
   int8_t          isInsertFromFile;  // load data from file or not
   uint8_t         msgType;
-  uint16_t        type;  // query type
 
   /*
    * use to keep short request msg and error msg, in such case, SSqlCmd->payload == SSqlCmd->ext;
@@ -255,8 +257,8 @@ typedef struct {
   short           numOfCols;
   int64_t         globalLimit;
   
-  SQueryInfo     *pQueryInfo;
-  int32_t         numOfQueries;
+  SQueryInfo    **pQueryInfo;
+  int32_t         numOfClause;
   
 //  char            intervalTimeUnit;
 //  int64_t         etime, stime;
@@ -421,12 +423,12 @@ int taos_retrieve(TAOS_RES *res);
  * transfer function for metric query in stream computing, the function need to be change
  * before send query message to vnode
  */
-int32_t tscTansformSQLFunctionForMetricQuery(SSqlCmd *pCmd);
-void    tscRestoreSQLFunctionForMetricQuery(SSqlCmd *pCmd);
+int32_t tscTansformSQLFunctionForMetricQuery(SQueryInfo* pQueryInfo);
+void    tscRestoreSQLFunctionForMetricQuery(SQueryInfo* pQueryInfo);
 
 void tscClearSqlMetaInfoForce(SSqlCmd *pCmd);
 
-int32_t tscCreateResPointerInfo(SSqlCmd *pCmd, SSqlRes *pRes);
+int32_t tscCreateResPointerInfo(SQueryInfo* pQueryInfo, SSqlRes *pRes);
 void    tscDestroyResPointerInfo(SSqlRes *pRes);
 
 void tscFreeSqlCmdData(SSqlCmd *pCmd);
@@ -454,6 +456,8 @@ void    tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowL
 bool    tscIsUpdateQuery(STscObj *pObj);
 bool    tscHasReachLimitation(SSqlObj* pSql);
 
+char* tscGetErrorMsgPayload(SSqlCmd* pCmd);
+
 int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *sql);
 
 // transfer SSqlInfo to SqlCmd struct

src/client/src/tscAsync.c

@@ -118,10 +118,12 @@ static void tscProcessAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOf
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
   // sequentially retrieve data from remain vnodes first, query vnode specified by vnodeIdx
-  if (numOfRows == 0 && tscProjectionQueryOnMetric(pCmd)) {
+  if (numOfRows == 0 && tscProjectionQueryOnMetric(pCmd, 0)) {
     // vnode is denoted by vnodeIdx, continue to query vnode specified by vnodeIdx
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
     assert(pMeterMetaInfo->vnodeIndex >= 0);
 
     /* reach the maximum number of output rows, abort */
@@ -131,8 +133,9 @@ static void tscProcessAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOf
     }
 
     /* update the limit value according to current retrieval results */
-    pCmd->pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
-    pCmd->pQueryInfo->limit.offset = pRes->offset;
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+    pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
+    pQueryInfo->limit.offset = pRes->offset;
 
     if ((++(pMeterMetaInfo->vnodeIndex)) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
       tscTrace("%p retrieve data from next vnode:%d", pSql, pMeterMetaInfo->vnodeIndex);
@@ -266,13 +269,14 @@ void tscProcessAsyncRetrieve(void *param, TAOS_RES *tres, int numOfRows) {
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   if (numOfRows == 0) {
     // sequentially retrieve data from remain vnodes.
-    if (tscProjectionQueryOnMetric(pCmd)) {
+    if (tscProjectionQueryOnMetric(pCmd, 0)) {
       /*
        * vnode is denoted by vnodeIdx, continue to query vnode specified by vnodeIdx till all vnode have been retrieved
        */
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
       assert(pMeterMetaInfo->vnodeIndex >= 0);
 
       /* reach the maximum number of output rows, abort */
@@ -282,7 +286,8 @@ void tscProcessAsyncRetrieve(void *param, TAOS_RES *tres, int numOfRows) {
       }
 
       /* update the limit value according to current retrieval results */
-      pCmd->pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
+      SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+      pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
 
       if ((++pMeterMetaInfo->vnodeIndex) <= pMeterMetaInfo->pMetricMeta->numOfVnodes) {
         pSql->cmd.command = TSDB_SQL_SELECT;  // reset flag to launch query first.
@@ -297,7 +302,7 @@ void tscProcessAsyncRetrieve(void *param, TAOS_RES *tres, int numOfRows) {
     }
   } else {
     for (int i = 0; i < pCmd->numOfCols; ++i)
-      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) + pRes->bytes[i] * pRes->row;
+      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
     pRes->row++;
 
     (*pSql->fetchFp)(pSql->param, pSql, pSql->res.tsrow);
@@ -308,9 +313,13 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
   SSqlObj *pSql = (SSqlObj *)pMsg->ahandle;
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
+  assert(0);
+  
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  assert(pCmd->numOfCols == pQueryInfo->fieldsInfo.numOfOutputCols);
 
   for (int i = 0; i < pCmd->numOfCols; ++i)
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) + pRes->bytes[i] * pRes->row;
+    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
   pRes->row++;
 
   (*pSql->fetchFp)(pSql->param, pSql, pRes->tsrow);
@@ -406,8 +415,11 @@ void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows)
 
   assert(!pCmd->isInsertFromFile && pSql->signature == pSql);
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-  assert(pCmd->pQueryInfo->numOfTables == 1);
+  int32_t index = 0;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, index);
+  
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, index, 0);
+  assert(pQueryInfo->numOfTables == 1);
   
   SDataBlockList *pDataBlocks = pCmd->pDataBlocks;
   if (pDataBlocks == NULL || pMeterMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
@@ -464,10 +476,11 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     } else {
       tscTrace("%p renew meterMeta successfully, command:%d, code:%d, thandle:%p, retry:%d",
           pSql, pSql->cmd.command, pSql->res.code, pSql->thandle, pSql->retry);
-
-      assert(tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta == NULL);
-      tscGetMeterMeta(pSql, tscGetMeterMetaInfo(&pSql->cmd, 0)->name, 0);
-
+  
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+      assert(pMeterMetaInfo->pMeterMeta == NULL);
+      
+      tscGetMeterMeta(pSql, pMeterMetaInfo->name, 0);
       code = tscSendMsgToServer(pSql);
       if (code != 0) {
         pRes->code = code;
@@ -486,18 +499,21 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
 
   if (pSql->pStream == NULL) {
     // check if it is a sub-query of metric query first, if true, enter another routine
-    if ((pSql->cmd.type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) == TSDB_QUERY_TYPE_STABLE_SUBQUERY) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+    if ((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) == TSDB_QUERY_TYPE_STABLE_SUBQUERY) {
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
       assert(pMeterMetaInfo->pMeterMeta->numOfTags != 0 && pMeterMetaInfo->vnodeIndex >= 0 && pSql->param != NULL);
 
       SRetrieveSupport *trs = (SRetrieveSupport *)pSql->param;
       SSqlObj *         pParObj = trs->pParentSqlObj;
+      
       assert(pParObj->signature == pParObj && trs->subqueryIndex == pMeterMetaInfo->vnodeIndex &&
           pMeterMetaInfo->pMeterMeta->numOfTags != 0);
 
       tscTrace("%p get metricMeta during metric query successfully", pSql);
-
-      code = tscGetMeterMeta(pSql, tscGetMeterMetaInfo(&pSql->cmd, 0)->name, 0);
+      
+      code = tscGetMeterMeta(pSql, pMeterMetaInfo->name, 0);
       pRes->code = code;
 
       if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
@@ -512,14 +528,14 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
   } else {  // stream computing
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
     code = tscGetMeterMeta(pSql, pMeterMetaInfo->name, 0);
     pRes->code = code;
 
     if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
-    pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+    pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
+    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
       code = tscGetMetricMeta(pSql);
       pRes->code = code;
 
@@ -539,7 +555,9 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
      * transfer the sql function for metric query before get meter/metric meta,
      * since in callback functions, only tscProcessSql(pStream->pSql) is executed!
      */
-    tscTansformSQLFunctionForMetricQuery(&pSql->cmd);
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+    
+    tscTansformSQLFunctionForMetricQuery(pQueryInfo);
     tscIncStreamExecutionCount(pSql->pStream);
   } else {
     tscTrace("%p get meterMeta/metricMeta successfully", pSql);

src/client/src/tscJoinProcess.c

@@ -53,11 +53,16 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSuppor
   *st = INT64_MAX;
   *et = INT64_MIN;
 
-  SLimitVal* pLimit = &pSql->cmd.pQueryInfo->limit;
-  int32_t    order = pSql->cmd.order.order;
-
-  pSql->pSubs[0]->cmd.pQueryInfo->tsBuf = output1;
-  pSql->pSubs[1]->cmd.pQueryInfo->tsBuf = output2;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SLimitVal* pLimit = &pQueryInfo->limit;
+  int32_t    order = pQueryInfo->order.order;
+  
+  SQueryInfo* pSubQueryInfo1 = tscGetQueryInfoDetail(&pSql->pSubs[0]->cmd, 0);
+  SQueryInfo* pSubQueryInfo2 = tscGetQueryInfoDetail(&pSql->pSubs[1]->cmd, 0);
+  
+  pSubQueryInfo1->tsBuf = output1;
+  pSubQueryInfo2->tsBuf = output2;
 
   tsBufResetPos(pSupporter1->pTSBuf);
   tsBufResetPos(pSupporter2->pTSBuf);
@@ -113,7 +118,9 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSuppor
       }
 
       // in case of stable query, limit/offset is not applied here
-      if (pLimit->offset == 0 || pSql->cmd.pQueryInfo->nAggTimeInterval > 0 || QUERY_IS_STABLE_QUERY(pSql->cmd.type)) {
+      SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+      
+      if (pLimit->offset == 0 || pQueryInfo->nAggTimeInterval > 0 || QUERY_IS_STABLE_QUERY(pQueryInfo->type)) {
         tsBufAppend(output1, elem1.vnode, elem1.tag, (const char*)&elem1.ts, sizeof(elem1.ts));
         tsBufAppend(output2, elem2.vnode, elem2.tag, (const char*)&elem2.ts, sizeof(elem2.ts));
       } else {
@@ -168,10 +175,12 @@ SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pS
   pSupporter->pState = pState;
 
   pSupporter->subqueryIndex = index;
-  pSupporter->interval = pSql->cmd.pQueryInfo->nAggTimeInterval;
-  pSupporter->limit = pSql->cmd.pQueryInfo->limit;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  pSupporter->interval = pQueryInfo->nAggTimeInterval;
+  pSupporter->limit = pQueryInfo->limit;
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, index);
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, index);
   pSupporter->uid = pMeterMetaInfo->pMeterMeta->uid;
 
   getTmpfilePath("join-", pSupporter->path);
@@ -209,10 +218,9 @@ void tscDestroyJoinSupporter(SJoinSubquerySupporter* pSupporter) {
  * primary timestamp column , the secondary query is not necessary
  *
  */
-bool needSecondaryQuery(SSqlObj* pSql) {
-  SSqlCmd* pCmd = &pSql->cmd;
-  for (int32_t i = 0; i < pCmd->pQueryInfo->colList.numOfCols; ++i) {
-    SColumnBase* pBase = tscColumnBaseInfoGet(&pCmd->pQueryInfo->colList, i);
+bool needSecondaryQuery(SQueryInfo* pQueryInfo) {
+  for (int32_t i = 0; i < pQueryInfo->colList.numOfCols; ++i) {
+    SColumnBase* pBase = tscColumnBaseInfoGet(&pQueryInfo->colList, i);
     if (pBase->colIndex.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
       return true;
     }
@@ -272,53 +280,58 @@ int32_t tscLaunchSecondSubquery(SSqlObj* pSql) {
     tscFreeSqlCmdData(&pNew->cmd);
 
     pSql->pSubs[j++] = pNew;
-    pNew->cmd.pQueryInfo->tsBuf = pSub->cmd.pQueryInfo->tsBuf;
-    pSub->cmd.pQueryInfo->tsBuf = NULL;
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0);
+    SQueryInfo* pSubQueryInfo = tscGetQueryInfoDetail(&pSub->cmd, 0);
+    
+    pQueryInfo->tsBuf = pSubQueryInfo->tsBuf;
+    pSubQueryInfo->tsBuf = NULL;
 
     taos_free_result(pSub);
 
     // set the second stage sub query for join process
-    pNew->cmd.type |= TSDB_QUERY_TYPE_JOIN_SEC_STAGE;
+    pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_SEC_STAGE;
 
-    pNew->cmd.pQueryInfo->nAggTimeInterval = pSupporter->interval;
-    pNew->cmd.pQueryInfo->groupbyExpr = pSupporter->groupbyExpr;
+    pQueryInfo->nAggTimeInterval = pSupporter->interval;
+    pQueryInfo->groupbyExpr = pSupporter->groupbyExpr;
 
-    tscColumnBaseInfoCopy(&pNew->cmd.pQueryInfo->colList, &pSupporter->colList, 0);
-    tscTagCondCopy(&pNew->cmd.pQueryInfo->tagCond, &pSupporter->tagCond);
+    tscColumnBaseInfoCopy(&pQueryInfo->colList, &pSupporter->colList, 0);
+    tscTagCondCopy(&pQueryInfo->tagCond, &pSupporter->tagCond);
 
-    tscSqlExprCopy(&pNew->cmd.pQueryInfo->exprsInfo, &pSupporter->exprsInfo, pSupporter->uid);
-    tscFieldInfoCopyAll(&pSupporter->fieldsInfo, &pNew->cmd.pQueryInfo->fieldsInfo);
+    tscSqlExprCopy(&pQueryInfo->exprsInfo, &pSupporter->exprsInfo, pSupporter->uid);
+    tscFieldInfoCopyAll(&pSupporter->fieldsInfo, &pQueryInfo->fieldsInfo);
 
     // add the ts function for interval query if it is missing
-    if (pSupporter->exprsInfo.pExprs[0].functionId != TSDB_FUNC_TS && pNew->cmd.pQueryInfo->nAggTimeInterval > 0) {
-      tscAddTimestampColumn(&pNew->cmd, TSDB_FUNC_TS, 0);
+    if (pSupporter->exprsInfo.pExprs[0].functionId != TSDB_FUNC_TS && pQueryInfo->nAggTimeInterval > 0) {
+      tscAddTimestampColumn(pQueryInfo, TSDB_FUNC_TS, 0);
     }
 
     // todo refactor function name
-    tscAddTimestampColumn(&pNew->cmd, TSDB_FUNC_TS, 0);
-    tscFieldInfoCalOffset(&pNew->cmd);
+    SQueryInfo* pNewQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0);
+    
+    tscAddTimestampColumn(pQueryInfo, TSDB_FUNC_TS, 0);
+    tscFieldInfoCalOffset(pNewQueryInfo);
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pNew->cmd, 0);
+    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pNewQueryInfo, 0);
 
     /*
      * When handling the projection query, the offset value will be modified for table-table join, which is changed
      * during the timestamp intersection.
      */
-    pSupporter->limit = pSql->cmd.pQueryInfo->limit;
-    pNew->cmd.pQueryInfo->limit = pSupporter->limit;
+    pSupporter->limit = pQueryInfo->limit;
+    pNewQueryInfo->limit = pSupporter->limit;
 
     // fetch the join tag column
-    if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
-      SSqlExpr* pExpr = tscSqlExprGet(&pNew->cmd, 0);
-      assert(pNew->cmd.pQueryInfo->tagCond.joinInfo.hasJoin);
+    if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+      SSqlExpr* pExpr = tscSqlExprGet(pNewQueryInfo, 0);
+      assert(pQueryInfo->tagCond.joinInfo.hasJoin);
 
-      int16_t tagColIndex = tscGetJoinTagColIndexByUid(&pNew->cmd.pQueryInfo->tagCond, pMeterMetaInfo->pMeterMeta->uid);
+      int16_t tagColIndex = tscGetJoinTagColIndexByUid(&pQueryInfo->tagCond, pMeterMetaInfo->pMeterMeta->uid);
       pExpr->param[0].i64Key = tagColIndex;
       pExpr->numOfParams = 1;
     }
 
 #ifdef _DEBUG_VIEW
-    tscPrintSelectClause(&pNew->cmd);
+    tscPrintSelectClause(&pNew->cmd, 0);
 #endif
 
     tscProcessSql(pNew);
@@ -370,10 +383,12 @@ static void quitAllSubquery(SSqlObj* pSqlObj, SJoinSubquerySupporter* pSupporter
 
 // update the query time range according to the join results on timestamp
 static void updateQueryTimeRange(SSqlObj* pSql, int64_t st, int64_t et) {
-  assert(pSql->cmd.pQueryInfo->stime <= st && pSql->cmd.pQueryInfo->etime >= et);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  assert(pQueryInfo->stime <= st && pQueryInfo->etime >= et);
 
-  pSql->cmd.pQueryInfo->stime = st;
-  pSql->cmd.pQueryInfo->etime = et;
+  pQueryInfo->stime = st;
+  pQueryInfo->etime = et;
 }
 
 static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
@@ -381,8 +396,9 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
   SSqlObj*                pParentSql = pSupporter->pObj;
 
   SSqlObj* pSql = (SSqlObj*)tres;
-
-  if ((pSql->cmd.type & TSDB_QUERY_TYPE_JOIN_SEC_STAGE) == 0) {
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  if ((pQueryInfo->type & TSDB_QUERY_TYPE_JOIN_SEC_STAGE) == 0) {
     if (pSupporter->pState->code != TSDB_CODE_SUCCESS) {
       tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows,
                pSupporter->pState->code);
@@ -408,8 +424,8 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
         tscTrace("%p create tmp file for ts block:%s", pSql, pBuf->path);
         pSupporter->pTSBuf = pBuf;
       } else {
-        assert(pSql->cmd.pQueryInfo->numOfTables == 1);  // for subquery, only one metermetaInfo
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
+        assert(pQueryInfo->numOfTables == 1);  // for subquery, only one metermetaInfo
+        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
         tsBufMerge(pSupporter->pTSBuf, pBuf, pMeterMetaInfo->vnodeIndex);
         tsBufDestory(pBuf);
@@ -422,9 +438,11 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
 
       taos_fetch_rows_a(tres, joinRetrieveCallback, param);
     } else if (numOfRows == 0) {  // no data from this vnode anymore
-      if (tscProjectionQueryOnMetric(&pParentSql->cmd)) {
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
-        assert(pSql->cmd.pQueryInfo->numOfTables == 1);
+      if (tscProjectionQueryOnMetric(&pSql->cmd, 0)) {
+        SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+        
+        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+        assert(pQueryInfo->numOfTables == 1);
 
         // for projection query, need to try next vnode
         if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
@@ -477,10 +495,12 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
     if (numOfRows >= 0) {
       pSql->res.numOfTotal += pSql->res.numOfRows;
     }
-
-    if (tscProjectionQueryOnMetric(&pSql->cmd) && numOfRows == 0) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
-      assert(pSql->cmd.pQueryInfo->numOfTables == 1);
+  
+    SSqlCmd* pCmd = &pSql->cmd;
+  
+    if (tscProjectionQueryOnMetric(pCmd, 0) && numOfRows == 0) {
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+      assert(pQueryInfo->numOfTables == 1);
 
       // for projection query, need to try next vnode if current vnode is exhausted
       if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
@@ -516,13 +536,14 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
 
   assert(pSql->numOfSubs >= 1);
 
+  
   for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
     SSqlRes *pRes = &pSql->pSubs[i]->res;
-    SSqlCmd *pCmd = &pSql->pSubs[i]->cmd;
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->pSubs[i]->cmd, 0);
   
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   
-    if (tscProjectionQueryOnMetric(pCmd)) {
+    if (tscProjectionQueryOnMetric(&pSql->cmd, 0)) {
       if (pRes->row >= pRes->numOfRows && pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes &&
           (!tscHasReachLimitation(pSql->pSubs[i]))) {
         numOfFetch++;
@@ -555,9 +576,11 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
 
     // wait for all subqueries completed
     pSupporter->pState->numOfTotal = numOfFetch;
-    assert(pRes1->numOfRows >= 0 && pCmd1->pQueryInfo->numOfTables == 1);
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd1, 0);
+    
+    assert(pRes1->numOfRows >= 0 && pQueryInfo->numOfTables == 1);
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd1, 0);
+    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
     
     if (pRes1->row >= pRes1->numOfRows) {
       tscTrace("%p subquery:%p retrieve data from vnode, subquery:%d, vnodeIndex:%d", pSql, pSql1,
@@ -589,16 +612,17 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
     return;  // the column transfer support struct has been built
   }
 
-  pRes->pColumnIndex = calloc(1, sizeof(SColumnIndex) * pCmd->pQueryInfo->fieldsInfo.numOfOutputCols);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  pRes->pColumnIndex = calloc(1, sizeof(SColumnIndex) * pQueryInfo->fieldsInfo.numOfOutputCols);
 
-  for (int32_t i = 0; i < pCmd->pQueryInfo->fieldsInfo.numOfOutputCols; ++i) {
-    SSqlExpr* pExpr = tscSqlExprGet(pCmd, i);
+  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutputCols; ++i) {
+    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
 
     int32_t tableIndexOfSub = -1;
-    for (int32_t j = 0; j < pCmd->pQueryInfo->numOfTables; ++j) {
+    for (int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
       SSqlObj* pSub = pSql->pSubs[j];
 
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSub->cmd, 0);
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSub->cmd, 0, 0);
       if (pMeterMetaInfo->pMeterMeta->uid == pExpr->uid) {
         tableIndexOfSub = j;
         break;
@@ -606,9 +630,10 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
     }
 
     SSqlCmd* pSubCmd = &pSql->pSubs[tableIndexOfSub]->cmd;
-
-    for (int32_t k = 0; k < pSubCmd->pQueryInfo->exprsInfo.numOfExprs; ++k) {
-      SSqlExpr* pSubExpr = tscSqlExprGet(pSubCmd, k);
+    SQueryInfo* pSubQueryInfo = tscGetQueryInfoDetail(pSubCmd, 0);
+    
+    for (int32_t k = 0; k < pSubQueryInfo->exprsInfo.numOfExprs; ++k) {
+      SSqlExpr* pSubExpr = tscSqlExprGet(pSubQueryInfo, k);
       if (pExpr->functionId == pSubExpr->functionId && pExpr->colInfo.colId == pSubExpr->colInfo.colId) {
         pRes->pColumnIndex[i] = (SColumnIndex){.tableIndex = tableIndexOfSub, .columnIndex = k};
         break;
@@ -619,7 +644,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
 
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   SSqlObj* pSql = (SSqlObj*)tres;
-  //  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
+  //  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
   //  int32_t idx = pSql->cmd.vnodeIdx;
 
@@ -648,7 +673,8 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
 
   //    }
   //  } else {
-  if ((pSql->cmd.type & TSDB_QUERY_TYPE_JOIN_SEC_STAGE) != TSDB_QUERY_TYPE_JOIN_SEC_STAGE) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  if ((pQueryInfo->type & TSDB_QUERY_TYPE_JOIN_SEC_STAGE) != TSDB_QUERY_TYPE_JOIN_SEC_STAGE) {
     if (code != TSDB_CODE_SUCCESS) {  // direct call joinRetrieveCallback and set the error code
       joinRetrieveCallback(param, pSql, code);
     } else {  // first stage query, continue to retrieve data
@@ -678,13 +704,14 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
       if (atomic_add_fetch_32(&pSupporter->pState->numOfCompleted, 1) >= pSupporter->pState->numOfTotal) {
         tscSetupOutputColumnIndex(pParentSql);
 
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
+        SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
         /**
          * if the query is a continue query (vnodeIndex > 0 for projection query) for next vnode, do the retrieval of
          * data instead of returning to its invoker
          */
-        if (pMeterMetaInfo->vnodeIndex > 0 && tscProjectionQueryOnMetric(&pSql->cmd)) {
+        if (pMeterMetaInfo->vnodeIndex > 0 && tscProjectionQueryOnMetric(&pSql->cmd, 0)) {
           assert(pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes);
           pSupporter->pState->numOfCompleted = 0;  // reset the record value
 

src/client/src/tscLocal.c

@@ -85,7 +85,7 @@ static int32_t getToStringLength(const char *pData, int32_t length, int32_t type
  * length((uint64_t) 123456789011) > 12, greater than sizsof(uint64_t)
  */
 static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) {
-  SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta;
+  SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta;
 
   if (pMeta->meterType == TSDB_METER_METRIC || pMeta->meterType == TSDB_METER_OTABLE ||
       pMeta->meterType == TSDB_METER_STABLE) {
@@ -114,8 +114,9 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSqlRes *pRes = &pSql->res;
 
   // one column for each row
-  SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   SMeterMeta *    pMeta = pMeterMetaInfo->pMeterMeta;
 
   /*
@@ -127,7 +128,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   int32_t numOfRows = pMeta->numOfColumns;
   int32_t totalNumOfRows = numOfRows + pMeta->numOfTags;
 
-  if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
     numOfRows = pMeta->numOfColumns + pMeta->numOfTags;
   }
 
@@ -135,31 +136,31 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSchema *pSchema = tsGetSchema(pMeta);
 
   for (int32_t i = 0; i < numOfRows; ++i) {
-    TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
+    TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
             TSDB_COL_NAME_LEN);
 
     char *type = tDataTypeDesc[pSchema[i].type].aName;
 
-    pField = tscFieldInfoGetField(pCmd, 1);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
+    pField = tscFieldInfoGetField(pQueryInfo, 1);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
 
     int32_t bytes = pSchema[i].bytes;
     if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
       bytes = bytes / TSDB_NCHAR_SIZE;
     }
 
-    pField = tscFieldInfoGetField(pCmd, 2);
-    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pCmd, 2) * totalNumOfRows + pField->bytes * i) = bytes;
+    pField = tscFieldInfoGetField(pQueryInfo, 2);
+    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 2) * totalNumOfRows + pField->bytes * i) = bytes;
 
-    pField = tscFieldInfoGetField(pCmd, 3);
+    pField = tscFieldInfoGetField(pQueryInfo, 3);
     if (i >= pMeta->numOfColumns && pMeta->numOfTags != 0) {
-      strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 3) * totalNumOfRows + pField->bytes * i, "tag",
+      strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i, "tag",
               strlen("tag") + 1);
     }
   }
 
-  if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
     return 0;
   }
 
@@ -167,27 +168,27 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   char *pTagValue = tsGetTagsValue(pMeta);
   for (int32_t i = numOfRows; i < totalNumOfRows; ++i) {
     // field name
-    TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
+    TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
             TSDB_COL_NAME_LEN);
 
     // type name
-    pField = tscFieldInfoGetField(pCmd, 1);
+    pField = tscFieldInfoGetField(pQueryInfo, 1);
     char *type = tDataTypeDesc[pSchema[i].type].aName;
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
 
     // type length
     int32_t bytes = pSchema[i].bytes;
-    pField = tscFieldInfoGetField(pCmd, 2);
+    pField = tscFieldInfoGetField(pQueryInfo, 2);
     if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
       bytes = bytes / TSDB_NCHAR_SIZE;
     }
 
-    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pCmd, 2) * totalNumOfRows + pField->bytes * i) = bytes;
+    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 2) * totalNumOfRows + pField->bytes * i) = bytes;
 
     // tag value
-    pField = tscFieldInfoGetField(pCmd, 3);
-    char *target = pRes->data + tscFieldInfoGetOffset(pCmd, 3) * totalNumOfRows + pField->bytes * i;
+    pField = tscFieldInfoGetField(pQueryInfo, 3);
+    char *target = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i;
 
     if (isNull(pTagValue, pSchema[i].type)) {
       sprintf(target, "%s", TSDB_DATA_NULL_STR);
@@ -252,25 +253,28 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->numOfCols = numOfCols;
 
-  pCmd->order.order = TSQL_SO_ASC;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  pQueryInfo->order.order = TSQL_SO_ASC;
 
-  tscFieldInfoSetValue(&pCmd->pQueryInfo->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, "Field", TSDB_COL_NAME_LEN);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, "Field", TSDB_COL_NAME_LEN);
   rowLen += TSDB_COL_NAME_LEN;
 
-  tscFieldInfoSetValue(&pCmd->pQueryInfo->fieldsInfo, 1, TSDB_DATA_TYPE_BINARY, "Type", typeColLength);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 1, TSDB_DATA_TYPE_BINARY, "Type", typeColLength);
   rowLen += typeColLength;
 
-  tscFieldInfoSetValue(&pCmd->pQueryInfo->fieldsInfo, 2, TSDB_DATA_TYPE_INT, "Length", sizeof(int32_t));
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 2, TSDB_DATA_TYPE_INT, "Length", sizeof(int32_t));
   rowLen += sizeof(int32_t);
 
-  tscFieldInfoSetValue(&pCmd->pQueryInfo->fieldsInfo, 3, TSDB_DATA_TYPE_BINARY, "Note", noteColLength);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 3, TSDB_DATA_TYPE_BINARY, "Note", noteColLength);
   rowLen += noteColLength;
 
   return rowLen;
 }
 
 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
-  assert(tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta != NULL);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  assert(tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta != NULL);
 
   const int32_t NUM_OF_DESCRIBE_TABLE_COLUMNS = 4;
   const int32_t TYPE_COLUMN_LENGTH = 16;
@@ -283,7 +287,7 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
 
   int32_t rowLen =
       tscBuildMeterSchemaResultFields(pSql, NUM_OF_DESCRIBE_TABLE_COLUMNS, TYPE_COLUMN_LENGTH, note_field_length);
-  tscFieldInfoCalOffset(&pSql->cmd);
+  tscFieldInfoCalOffset(pQueryInfo);
   return tscSetValueToResObj(pSql, rowLen);
 }
 
@@ -293,7 +297,9 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   // only need to reorganize the results in the column format
   SSqlCmd *       pCmd = &pSql->cmd;
   SSqlRes *       pRes = &pSql->res;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   SMetricMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
   SSchema *    pSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
@@ -310,7 +316,7 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   }
 
   int32_t totalNumOfResults = pMetricMeta->numOfMeters;
-  int32_t rowLen = tscGetResRowLength(pCmd);
+  int32_t rowLen = tscGetResRowLength(pQueryInfo);
 
   tscInitResObjForLocalQuery(pSql, totalNumOfResults, rowLen);
 
@@ -320,17 +326,17 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
 
     for (int32_t j = 0; j < pSidList->numOfSids; ++j) {
       SMeterSidExtInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
-
-      for (int32_t k = 0; k < pCmd->pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
-        SColIndexEx *pColIndex = &tscSqlExprGet(pCmd, k)->colInfo;
+      
+      for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
+        SColIndexEx *pColIndex = &tscSqlExprGet(pQueryInfo, k)->colInfo;
         int16_t      offsetId = pColIndex->colIdx;
 
         assert((pColIndex->flag & TSDB_COL_TAG) != 0);
 
         char *      val = pSidExt->tags + vOffset[offsetId];
-        TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, k);
+        TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
-        memcpy(pRes->data + tscFieldInfoGetOffset(pCmd, k) * totalNumOfResults + pField->bytes * rowIdx, val,
+        memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, k) * totalNumOfResults + pField->bytes * rowIdx, val,
                (size_t)pField->bytes);
       }
       rowIdx++;
@@ -344,21 +350,23 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
-  SMetricMeta *pMetricMeta = tscGetMeterMetaInfo(pCmd, 0)->pMetricMeta;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMetricMeta *pMetricMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMetricMeta;
   int32_t      totalNumOfResults = 1;  // count function only produce one result
-  int32_t      rowLen = tscGetResRowLength(pCmd);
+  int32_t      rowLen = tscGetResRowLength(pQueryInfo);
 
   tscInitResObjForLocalQuery(pSql, totalNumOfResults, rowLen);
 
   int32_t rowIdx = 0;
   for (int32_t i = 0; i < totalNumOfResults; ++i) {
-    for (int32_t k = 0; k < pCmd->pQueryInfo[0].fieldsInfo.numOfOutputCols; ++k) {
-      SSqlExpr *pExpr = tscSqlExprGet(pCmd, i);
+    for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
+      SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
 
       if (pExpr->colInfo.colIdx == -1 && pExpr->functionId == TSDB_FUNC_COUNT) {
-        TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, k);
+        TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
-        memcpy(pRes->data + tscFieldInfoGetOffset(pCmd, i) * totalNumOfResults + pField->bytes * rowIdx,
+        memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, i) * totalNumOfResults + pField->bytes * rowIdx,
                &pMetricMeta->numOfMeters, sizeof(pMetricMeta->numOfMeters));
       } else {
         tscError("not support operations");
@@ -373,15 +381,17 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
 
 static int tscProcessQueryTags(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
-
-  SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0)->pMeterMeta;
+  
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMeterMeta *pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta;
   if (pMeterMeta == NULL || pMeterMeta->numOfTags == 0 || pMeterMeta->numOfColumns == 0) {
     strcpy(pCmd->payload, "invalid table");
     pSql->res.code = TSDB_CODE_INVALID_TABLE;
     return pSql->res.code;
   }
 
-  SSqlExpr *pExpr = tscSqlExprGet(pCmd, 0);
+  SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, 0);
   if (pExpr->functionId == TSDB_FUNC_COUNT) {
     return tscBuildMetricTagSqlFunctionResult(pSql);
   } else {
@@ -390,7 +400,9 @@ static int tscProcessQueryTags(SSqlObj *pSql) {
 }
 
 static void tscProcessCurrentUser(SSqlObj *pSql) {
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, pSql->pTscObj->user, pExpr->aliasName, TSDB_USER_LEN);
 }
 
@@ -403,19 +415,24 @@ static void tscProcessCurrentDB(SSqlObj *pSql) {
     setNull(db, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN);
   }
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, db, pExpr->aliasName, TSDB_DB_NAME_LEN);
 }
 
 static void tscProcessServerVer(SSqlObj *pSql) {
   const char* v = pSql->pTscObj->sversion;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, v, pExpr->aliasName, tListLen(pSql->pTscObj->sversion));
 }
 
 static void tscProcessClientVer(SSqlObj *pSql) {
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, version, pExpr->aliasName, strlen(version));
 }
 
@@ -433,7 +450,9 @@ static void tscProcessServStatus(SSqlObj *pSql) {
     }
   }
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, "1", pExpr->aliasName, 2);
 }
 
@@ -442,12 +461,13 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
   SSqlRes *pRes = &pSql->res;
 
   pCmd->numOfCols = 1;
-  pCmd->order.order = TSQL_SO_ASC;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  pQueryInfo->order.order = TSQL_SO_ASC;
 
-  tscFieldInfoSetValue(&pCmd->pQueryInfo[0].fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, columnName, valueLength);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, columnName, valueLength);
   tscInitResObjForLocalQuery(pSql, 1, valueLength);
 
-  TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
+  TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
   strncpy(pRes->data, val, pField->bytes);
 }
 

src/client/src/tscParseInsert.c

@@ -651,7 +651,7 @@ void sortRemoveDuplicates(STableDataBlocks *dataBuf) {
 static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char **str, SParsedDataColInfo *spd,
                                       int32_t *totalNum) {
   SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   SMeterMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
 
   STableDataBlocks *dataBuf = NULL;
@@ -707,7 +707,7 @@ static int32_t tscParseSqlForCreateTableOnDemand(char **sqlstr, SSqlObj *pSql) {
   int32_t   code = TSDB_CODE_SUCCESS;
 
   SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
 
   char *sql = *sqlstr;
   // get the token of specified table
@@ -754,7 +754,7 @@ static int32_t tscParseSqlForCreateTableOnDemand(char **sqlstr, SSqlObj *pSql) {
 
     STagData *pTag = (STagData *)pCmd->payload;
     memset(pTag, 0, sizeof(STagData));
-    setMeterID(pSql, &sToken, 0);
+    setMeterID(pSql, 0, &sToken, 0);
 
     strncpy(pTag->name, pMeterMetaInfo->name, TSDB_METER_ID_LEN);
     code = tscGetMeterMeta(pSql, pTag->name, 0);
@@ -762,7 +762,7 @@ static int32_t tscParseSqlForCreateTableOnDemand(char **sqlstr, SSqlObj *pSql) {
       return code;
     }
 
-    if (!UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+    if (!UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
       return tscInvalidSQLErrMsg(pCmd->payload, "create table only from super table is allowed", sToken.z);
     }
 
@@ -894,7 +894,7 @@ static int32_t tscParseSqlForCreateTableOnDemand(char **sqlstr, SSqlObj *pSql) {
       return tscInvalidSQLErrMsg(pCmd->payload, "invalid table name", *sqlstr);
     }
 
-    int32_t ret = setMeterID(pSql, &tableToken, 0);
+    int32_t ret = setMeterID(pSql, 0, &tableToken, 0);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -941,13 +941,13 @@ int validateTableName(char *tblName, int len) {
  * @param pSql
  * @return
  */
-int doParserInsertSql(SSqlObj *pSql, char *str) {
+int doParseInsertSql(SSqlObj *pSql, char *str) {
   SSqlCmd *pCmd = &pSql->cmd;
   
   int32_t code = TSDB_CODE_INVALID_SQL;
   int32_t totalNum = 0;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pCmd);
+  SMeterMetaInfo *pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pCmd, 0);
 
   if ((code = tscAllocPayload(pCmd, TSDB_PAYLOAD_SIZE)) != TSDB_CODE_SUCCESS) {
     return code;
@@ -992,7 +992,7 @@ int doParserInsertSql(SSqlObj *pSql, char *str) {
     }
 
     //TODO refactor
-    if ((code = setMeterID(pSql, &sToken, 0)) != TSDB_CODE_SUCCESS) {
+    if ((code = setMeterID(pSql, 0, &sToken, 0)) != TSDB_CODE_SUCCESS) {
       goto _error_clean;
     }
 
@@ -1011,7 +1011,7 @@ int doParserInsertSql(SSqlObj *pSql, char *str) {
       }
     }
 
-    if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+    if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
       code = tscInvalidSQLErrMsg(pCmd->payload, "insert data into super table is not supported", NULL);
       goto _error_clean;
     }
@@ -1088,7 +1088,7 @@ int doParserInsertSql(SSqlObj *pSql, char *str) {
       strcpy(pDataBlock->filename, fname);
     } else if (sToken.type == TK_LP) {
       /* insert into tablename(col1, col2,..., coln) values(v1, v2,... vn); */
-      SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0)->pMeterMeta;
+      SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0, 0)->pMeterMeta;
       SSchema *   pSchema = tsGetSchema(pMeterMeta);
 
       if (pCmd->isInsertFromFile == -1) {
@@ -1188,7 +1188,7 @@ int doParserInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
     
     // set the next sent data vnode index in data block arraylist
     pMeterMetaInfo->vnodeIndex = 1;
@@ -1203,7 +1203,7 @@ _error_clean:
   pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
 
 _clean:
-  taosCleanUpIntHash(pSql->pTableHashList);
+  taosCleanUpHashTable(pSql->pTableHashList);
   pSql->pTableHashList = NULL;
   return code;
 }
@@ -1231,14 +1231,14 @@ int tsParseInsertSql(SSqlObj *pSql, char *sql, char *acct, char *db) {
   pCmd->isInsertFromFile = -1;
   pSql->res.numOfRows = 0;
   
-  return doParserInsertSql(pSql, sql + index);
+  return doParseInsertSql(pSql, sql + index);
 }
 
 int tsParseSql(SSqlObj *pSql, char *acct, char *db, bool multiVnodeInsertion) {
   int32_t ret = TSDB_CODE_SUCCESS;
 
   // must before clean the sqlcmd object
-  tscRemoveAllMeterMetaInfo(&pSql->cmd, false);
+//  tscRemoveMeterMetaInfo(&pSql->cmd, false);
   
   if (NULL == pSql->asyncTblPos) {
     tscCleanSqlCmd(&pSql->cmd);
@@ -1287,7 +1287,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   int32_t  code = TSDB_CODE_SUCCESS;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0)->pMeterMeta;
+  SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0, 0)->pMeterMeta;
 
   SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(pTableDataBlocks->pData);
   tsSetBlockInfo(pBlocks, pMeterMeta, numOfRows);
@@ -1319,7 +1319,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
   int             numOfRows = 0;
   int32_t         code = 0;
   int             nrows = 0;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   SMeterMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
   int32_t         rowSize = pMeterMeta->rowSize;
 
@@ -1415,7 +1415,7 @@ void tscProcessMultiVnodesInsert(SSqlObj *pSql) {
   }
 
   STableDataBlocks *pDataBlock = NULL;
-  SMeterMetaInfo *  pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *  pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   int32_t           code = TSDB_CODE_SUCCESS;
 
   /* the first block has been sent to server in processSQL function */
@@ -1450,7 +1450,7 @@ void tscProcessMultiVnodesInsertForFile(SSqlObj *pSql) {
     return;
   }
 
-  SMeterMetaInfo *  pInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *  pInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   STableDataBlocks *pDataBlock = NULL;
   int32_t           affected_rows = 0;
 

src/client/src/tscPrepare.c

@@ -409,7 +409,7 @@ static int insertStmtReset(STscStmt* pStmt) {
   }
   pCmd->batchSize = 0;
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   pMeterMetaInfo->vnodeIndex = 0;
   return TSDB_CODE_SUCCESS;
 }
@@ -423,7 +423,7 @@ static int insertStmtExecute(STscStmt* stmt) {
     ++pCmd->batchSize;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   
   if (pCmd->pDataBlocks->nSize > 0) {
     // merge according to vgid

src/client/src/tscSql.c

@@ -128,8 +128,7 @@ TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const
   }
 
   pSql->cmd.command = TSDB_SQL_CONNECT;
-  int ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
-  if (TSDB_CODE_SUCCESS != ret) {
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     globalCode = TSDB_CODE_CLI_OUT_OF_MEMORY;
     free(pSql);
     free(pObj);
@@ -298,7 +297,8 @@ int taos_num_fields(TAOS_RES *res) {
   SSqlObj *pSql = (SSqlObj *)res;
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  SFieldInfo *pFieldsInfo = &pSql->cmd.pQueryInfo[0].fieldsInfo;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  SFieldInfo *pFieldsInfo = &pQueryInfo->fieldsInfo;
 
   return (pFieldsInfo->numOfOutputCols - pFieldsInfo->numOfHiddenCols);
 }
@@ -320,8 +320,9 @@ int taos_affected_rows(TAOS *taos) {
 TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
   SSqlObj *pSql = (SSqlObj *)res;
   if (pSql == NULL || pSql->signature != pSql) return 0;
-
-  return pSql->cmd.pQueryInfo[0].fieldsInfo.pFields;
+  
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  return pQueryInfo->fieldsInfo.pFields;
 }
 
 int taos_retrieve(TAOS_RES *res) {
@@ -370,31 +371,33 @@ int taos_fetch_block_impl(TAOS_RES *res, TAOS_ROW *rows) {
     pRes->numOfTotal += pRes->numOfRows;
   }
 
-  for (int i = 0; i < pCmd->pQueryInfo[0].fieldsInfo.numOfOutputCols; ++i) {
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) +
-                     pRes->bytes[i] * (1 - pCmd->order.order) * (pRes->numOfRows - 1);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  for (int i = 0; i < pQueryInfo->fieldsInfo.numOfOutputCols; ++i) {
+    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) +
+                     pRes->bytes[i] * (1 - pQueryInfo->order.order) * (pRes->numOfRows - 1);
   }
 
   *rows = pRes->tsrow;
 
-  return (pCmd->order.order == TSQL_SO_DESC) ? pRes->numOfRows : -pRes->numOfRows;
+  return (pQueryInfo->order.order == TSQL_SO_DESC) ? pRes->numOfRows : -pRes->numOfRows;
 }
 
 static void **doSetResultRowData(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
-
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
   int32_t num = 0;
 
-  for (int i = 0; i < pCmd->pQueryInfo[0].fieldsInfo.numOfOutputCols; ++i) {
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) + pRes->bytes[i] * pRes->row;
+  for (int i = 0; i < pQueryInfo->fieldsInfo.numOfOutputCols; ++i) {
+    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
 
     // primary key column cannot be null in interval query, no need to check
-    if (i == 0 && pCmd->pQueryInfo[0].nAggTimeInterval > 0) {
+    if (i == 0 && pQueryInfo->nAggTimeInterval > 0) {
       continue;
     }
 
-    TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, i);
+    TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, i);
 
     if (isNull(pRes->tsrow[i], pField->type)) {
       pRes->tsrow[i] = NULL;
@@ -419,7 +422,7 @@ static void **doSetResultRowData(SSqlObj *pSql) {
     }
   }
 
-  assert(num <= pCmd->pQueryInfo[0].fieldsInfo.numOfOutputCols);
+  assert(num <= pQueryInfo->fieldsInfo.numOfOutputCols);
 
   return pRes->tsrow;
 }
@@ -437,15 +440,17 @@ static bool tscHashRemainDataInSubqueryResultSet(SSqlObj *pSql) {
   bool     hasData = true;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  if (tscProjectionQueryOnMetric(pCmd)) {
+  if (tscProjectionQueryOnMetric(pCmd, 0)) {
     bool allSubqueryExhausted = true;
 
     for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
       SSqlRes *pRes1 = &pSql->pSubs[i]->res;
       SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
 
-      SMeterMetaInfo *pMetaInfo = tscGetMeterMetaInfo(pCmd1, 0);
-      assert(pCmd1->pQueryInfo[0].numOfTables == 1);
+      SMeterMetaInfo *pMetaInfo = tscGetMeterMetaInfo(pCmd1, 0, 0);
+  
+      SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+      assert(pQueryInfo->numOfTables == 1);
 
       /*
        * if the global limitation is not reached, and current result has not exhausted, or next more vnodes are
@@ -462,10 +467,10 @@ static bool tscHashRemainDataInSubqueryResultSet(SSqlObj *pSql) {
   } else {  // otherwise, in case inner join, if any subquery exhausted, query completed.
     for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
       SSqlRes *pRes1 = &pSql->pSubs[i]->res;
-
+      SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->pSubs[i]->cmd, 0);
+      
       if ((pRes1->row >= pRes1->numOfRows && tscHasReachLimitation(pSql->pSubs[i]) &&
-           tscProjectionQueryOnTable(&pSql->pSubs[i]->cmd)) ||
-          (pRes1->numOfRows == 0)) {
+           tscProjectionQueryOnTable(pQueryInfo)) || (pRes1->numOfRows == 0)) {
         
         hasData = false;
         break;
@@ -477,7 +482,6 @@ static bool tscHashRemainDataInSubqueryResultSet(SSqlObj *pSql) {
 }
 
 static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
-  SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
   while (1) {
@@ -498,9 +502,11 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
       free(pState);
       return NULL;
     }
-
+  
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
     if (pRes->tsrow == NULL) {
-      pRes->tsrow = malloc(POINTER_BYTES * pCmd->pQueryInfo[0].exprsInfo.numOfExprs);
+      pRes->tsrow = malloc(POINTER_BYTES * pQueryInfo->exprsInfo.numOfExprs);
     }
 
     bool success = false;
@@ -526,7 +532,7 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
     }
 
     if (success) {  // current row of final output has been built, return to app
-      for (int32_t i = 0; i < pCmd->pQueryInfo[0].exprsInfo.numOfExprs; ++i) {
+      for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {
         int32_t tableIndex = pRes->pColumnIndex[i].tableIndex;
         int32_t columnIndex = pRes->pColumnIndex[i].columnIndex;
 
@@ -599,8 +605,11 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
 
   // projection query on metric, pipeline retrieve data from vnode list, instead of two-stage merge
   TAOS_ROW rows = taos_fetch_row_impl(res);
-  while (rows == NULL && tscProjectionQueryOnMetric(pCmd)) {
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  while (rows == NULL && tscProjectionQueryOnMetric(pCmd, 0)) {
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
     // reach the maximum number of output rows, abort
     if (tscHasReachLimitation(pSql)) {
@@ -611,8 +620,8 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
      * update the limit and offset value according to current retrieval results
      * Note: if pRes->offset > 0, pRes->numOfRows = 0, pRes->numOfTotal = 0;
      */
-    pCmd->pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
-    pCmd->pQueryInfo->limit.offset = pRes->offset;
+    pQueryInfo->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
+    pQueryInfo->limit.offset = pRes->offset;
 
     assert((pRes->offset >= 0 && pRes->numOfRows == 0) || (pRes->offset == 0 && pRes->numOfRows >= 0));
 
@@ -656,17 +665,19 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
   // projection query on metric, pipeline retrieve data from vnode list,
   // instead of two-stage mergevnodeProcessMsgFromShell free qhandle
   nRows = taos_fetch_block_impl(res, rows);
-  while (*rows == NULL && tscProjectionQueryOnMetric(pCmd)) {
+  
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  while (*rows == NULL && tscProjectionQueryOnMetric(pCmd, 0)) {
     /* reach the maximum number of output rows, abort */
     if (tscHasReachLimitation(pSql)) {
       return 0;
     }
 
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
     /* update the limit value according to current retrieval results */
-    pCmd->pQueryInfo->limit.limit = pSql->cmd.globalLimit - pRes->numOfTotal;
-    pCmd->pQueryInfo->limit.offset = pRes->offset;
+    pQueryInfo->limit.limit = pSql->cmd.globalLimit - pRes->numOfTotal;
+    pQueryInfo->limit.offset = pRes->offset;
 
     if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
       pSql->cmd.command = TSDB_SQL_SELECT;
@@ -723,9 +734,10 @@ void taos_free_result(TAOS_RES *res) {
   }
 
   // set freeFlag to 1 in retrieve message if there are un-retrieved results
-  pCmd->type = TSDB_QUERY_TYPE_FREE_RESOURCE;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  pQueryInfo->type = TSDB_QUERY_TYPE_FREE_RESOURCE;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   /*
    * case 1. Partial data have been retrieved from vnodes, but not all data has been retrieved yet.
@@ -971,7 +983,6 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
 static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t tblListLen) {
   // must before clean the sqlcmd object
-  tscRemoveAllMeterMetaInfo(&pSql->cmd, false);
   tscCleanSqlCmd(&pSql->cmd);
 
   SSqlCmd *pCmd = &pSql->cmd;
@@ -982,7 +993,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
   int   code = TSDB_CODE_INVALID_METER_ID;
   char *str = (char *)tblNameList;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pCmd);
+  SMeterMetaInfo *pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pCmd, 0);
 
   if ((code = tscAllocPayload(pCmd, tblListLen + 16)) != TSDB_CODE_SUCCESS) {
     return code;
@@ -1017,7 +1028,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       return code;
     }
 
-    if ((code = setMeterID(pSql, &sToken, 0)) != TSDB_CODE_SUCCESS) {
+    if ((code = setMeterID(pSql, 0, &sToken, 0)) != TSDB_CODE_SUCCESS) {
       return code;
     }
 

src/inc/sql.y

@@ -354,7 +354,8 @@ select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) fill_
 
 union(Y) ::= select(X). { Y = setSubclause(NULL, X); }
 union(Y) ::= LP union(X) RP. { Y = X; }
-union(Y) ::= union(Z) UNION select(X). { Y = appendSelectClause(Z, X); }
+union(Y) ::= union(Z) UNION ALL select(X). { Y = appendSelectClause(Z, X); }
+union(Y) ::= union(Z) UNION ALL LP select(X) RP. { Y = appendSelectClause(Z, X); }
 
 cmd ::= union(X). { setSQLInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
 

src/inc/tsdb.h

@@ -186,6 +186,7 @@ extern "C" {
 #define TSDB_MAX_TABLES_PER_VNODE       220000
 
 #define TSDB_MAX_JOIN_TABLE_NUM         5
+#define TSDB_MAX_UNION_CLAUSE           5
 
 #define TSDB_MAX_BINARY_LEN            (TSDB_MAX_BYTES_PER_ROW-TSDB_KEYSIZE)
 #define TSDB_MAX_NCHAR_LEN             (TSDB_MAX_BYTES_PER_ROW-TSDB_KEYSIZE)

src/inc/tsqldef.h

@@ -120,66 +120,66 @@
 #define TK_NULL                           102
 #define TK_SELECT                         103
 #define TK_UNION                          104
-#define TK_FROM                           105
-#define TK_VARIABLE                       106
-#define TK_INTERVAL                       107
-#define TK_FILL                           108
-#define TK_SLIDING                        109
-#define TK_ORDER                          110
-#define TK_BY                             111
-#define TK_ASC                            112
-#define TK_DESC                           113
-#define TK_GROUP                          114
-#define TK_HAVING                         115
-#define TK_LIMIT                          116
-#define TK_OFFSET                         117
-#define TK_SLIMIT                         118
-#define TK_SOFFSET                        119
-#define TK_WHERE                          120
-#define TK_NOW                            121
-#define TK_RESET                          122
-#define TK_QUERY                          123
-#define TK_ADD                            124
-#define TK_COLUMN                         125
-#define TK_TAG                            126
-#define TK_CHANGE                         127
-#define TK_SET                            128
-#define TK_KILL                           129
-#define TK_CONNECTION                     130
-#define TK_COLON                          131
-#define TK_STREAM                         132
-#define TK_ABORT                          133
-#define TK_AFTER                          134
-#define TK_ATTACH                         135
-#define TK_BEFORE                         136
-#define TK_BEGIN                          137
-#define TK_CASCADE                        138
-#define TK_CLUSTER                        139
-#define TK_CONFLICT                       140
-#define TK_COPY                           141
-#define TK_DEFERRED                       142
-#define TK_DELIMITERS                     143
-#define TK_DETACH                         144
-#define TK_EACH                           145
-#define TK_END                            146
-#define TK_EXPLAIN                        147
-#define TK_FAIL                           148
-#define TK_FOR                            149
-#define TK_IGNORE                         150
-#define TK_IMMEDIATE                      151
-#define TK_INITIALLY                      152
-#define TK_INSTEAD                        153
-#define TK_MATCH                          154
-#define TK_KEY                            155
-#define TK_OF                             156
-#define TK_RAISE                          157
-#define TK_REPLACE                        158
-#define TK_RESTRICT                       159
-#define TK_ROW                            160
-#define TK_STATEMENT                      161
-#define TK_TRIGGER                        162
-#define TK_VIEW                           163
-#define TK_ALL                            164
+#define TK_ALL                            105
+#define TK_FROM                           106
+#define TK_VARIABLE                       107
+#define TK_INTERVAL                       108
+#define TK_FILL                           109
+#define TK_SLIDING                        110
+#define TK_ORDER                          111
+#define TK_BY                             112
+#define TK_ASC                            113
+#define TK_DESC                           114
+#define TK_GROUP                          115
+#define TK_HAVING                         116
+#define TK_LIMIT                          117
+#define TK_OFFSET                         118
+#define TK_SLIMIT                         119
+#define TK_SOFFSET                        120
+#define TK_WHERE                          121
+#define TK_NOW                            122
+#define TK_RESET                          123
+#define TK_QUERY                          124
+#define TK_ADD                            125
+#define TK_COLUMN                         126
+#define TK_TAG                            127
+#define TK_CHANGE                         128
+#define TK_SET                            129
+#define TK_KILL                           130
+#define TK_CONNECTION                     131
+#define TK_COLON                          132
+#define TK_STREAM                         133
+#define TK_ABORT                          134
+#define TK_AFTER                          135
+#define TK_ATTACH                         136
+#define TK_BEFORE                         137
+#define TK_BEGIN                          138
+#define TK_CASCADE                        139
+#define TK_CLUSTER                        140
+#define TK_CONFLICT                       141
+#define TK_COPY                           142
+#define TK_DEFERRED                       143
+#define TK_DELIMITERS                     144
+#define TK_DETACH                         145
+#define TK_EACH                           146
+#define TK_END                            147
+#define TK_EXPLAIN                        148
+#define TK_FAIL                           149
+#define TK_FOR                            150
+#define TK_IGNORE                         151
+#define TK_IMMEDIATE                      152
+#define TK_INITIALLY                      153
+#define TK_INSTEAD                        154
+#define TK_MATCH                          155
+#define TK_KEY                            156
+#define TK_OF                             157
+#define TK_RAISE                          158
+#define TK_REPLACE                        159
+#define TK_RESTRICT                       160
+#define TK_ROW                            161
+#define TK_STATEMENT                      162
+#define TK_TRIGGER                        163
+#define TK_VIEW                           164
 #define TK_COUNT                          165
 #define TK_SUM                            166
 #define TK_AVG                            167

src/inc/tutil.h

@@ -102,8 +102,8 @@ extern "C" {
   #define GET_FLOAT_VAL(x)  taos_align_get_float(x)
   #define GET_DOUBLE_VAL(x) taos_align_get_double(x)
 
-  float  taos_align_get_float(char* pBuf);
-  double taos_align_get_double(char* pBuf);
+  float  taos_align_get_float(const char* pBuf);
+  double taos_align_get_double(const char* pBuf);
 
   //#define __float_align_declear()  float __underlyFloat = 0.0;
   //#define __float_align_declear()

src/util/src/hash.c

@@ -480,6 +480,8 @@ void taosCleanUpHashTable(void *handle) {
         free(pNode);
         pNode = pNext;
       }
+      
+      tfree(pEntry);
     }
 
     free(pObj->hashList);

src/util/src/tutil.c

@@ -528,13 +528,13 @@ char *taosIpStr(uint32_t ipInt) {
 void taosCleanupTier() {}
 #endif
 
-FORCE_INLINE float taos_align_get_float(char* pBuf) {
+FORCE_INLINE float taos_align_get_float(const char* pBuf) {
   float fv = 0; 
   *(int32_t*)(&fv) = *(int32_t*)pBuf;
   return fv; 
 }
 
-FORCE_INLINE double taos_align_get_double(char* pBuf) {
+FORCE_INLINE double taos_align_get_double(const char* pBuf) {
   double dv = 0; 
   *(int64_t*)(&dv) = *(int64_t*)pBuf;
   return dv;