diff --git a/Jenkinsfile2 b/Jenkinsfile2
index a2043797c0..441cf89626 100644
--- a/Jenkinsfile2
+++ b/Jenkinsfile2
@@ -88,12 +88,6 @@ def pre_test(){
     cmake .. > /dev/null
     make -j4> /dev/null
     '''
-    sh'''
-    cd ${WKPY}
-    git reset --hard
-    git pull
-    pip3 install .
-    '''
     return 1
 }
 
@@ -103,7 +97,6 @@ pipeline {
   environment{
       WK = '/var/lib/jenkins/workspace/TDinternal'
       WKC= '/var/lib/jenkins/workspace/TDengine'
-      WKPY= '/var/lib/jenkins/workspace/taos-connector-python'
   }
   stages {
       stage('pre_build'){
@@ -124,11 +117,6 @@ pipeline {
               ./test-all.sh b1fq
               '''
               sh'''
-              export LD_LIBRARY_PATH=${WKC}/debug/build/lib
-              cd ${WKC}/tests/system-test
-              ./fulltest.sh
-              '''
-              sh'''
               cd ${WKC}/debug
               ctest
               '''
diff --git a/include/common/taosdef.h b/include/common/taosdef.h
index 6e344dfdb4..af8bda2593 100644
--- a/include/common/taosdef.h
+++ b/include/common/taosdef.h
@@ -78,13 +78,6 @@ typedef enum {
   TSDB_SMA_TYPE_ROLLUP = 2,      // Rollup SMA
 } ETsdbSmaType;
 
-typedef enum {
-  TSDB_BSMA_TYPE_NONE = 0,  // no block-wise SMA
-  TSDB_BSMA_TYPE_I = 1,     // sum/min/max(default)
-} ETsdbBSmaType;
-
-#define TSDB_BSMA_TYPE_LATEST TSDB_BSMA_TYPE_I
-
 extern char *qtypeStr[];
 
 #define TSDB_PORT_HTTP      11
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index fac75e7fc6..5ea53b5510 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -326,11 +326,20 @@ int32_t tDecodeSEpSet(SCoder* pDecoder, SEpSet* pEp);
 int32_t taosEncodeSEpSet(void** buf, const SEpSet* pEp);
 void*   taosDecodeSEpSet(const void* buf, SEpSet* pEp);
 
+typedef struct {
+  SEpSet epSet;
+} SMEpSet;
+
+int32_t tSerializeSMEpSet(void* buf, int32_t bufLen, SMEpSet* pReq);
+int32_t tDeserializeSMEpSet(void* buf, int32_t buflen, SMEpSet* pReq);
+
 typedef struct {
   int8_t  connType;
   int32_t pid;
   char    app[TSDB_APP_NAME_LEN];
   char    db[TSDB_DB_NAME_LEN];
+  char    user[TSDB_USER_LEN];
+  char    passwd[TSDB_PASSWORD_LEN];
   int64_t startTime;
 } SConnectReq;
 
@@ -482,7 +491,7 @@ typedef struct {
   char    intervalUnit;
   char    slidingUnit;
   char
-      offsetUnit;  // TODO Remove it, the offset is the number of precision tickle, and it must be a immutable duration.
+          offsetUnit;  // TODO Remove it, the offset is the number of precision tickle, and it must be a immutable duration.
   int8_t  precision;
   int64_t interval;
   int64_t sliding;
@@ -982,7 +991,6 @@ int32_t tDeserializeSShowRsp(void* buf, int32_t bufLen, SShowRsp* pRsp);
 void    tFreeSShowRsp(SShowRsp* pRsp);
 
 typedef struct {
-  int32_t type;
   char    db[TSDB_DB_FNAME_LEN];
   char    tb[TSDB_TABLE_NAME_LEN];
   int64_t showId;
@@ -1275,11 +1283,16 @@ typedef struct {
 } SMVCreateStreamRsp, SMSCreateStreamRsp;
 
 typedef struct {
-  char   name[TSDB_TOPIC_FNAME_LEN];
-  int8_t igExists;
-  char*  sql;
-  char*  ast;
-  char   subscribeDbName[TSDB_DB_NAME_LEN];
+  char    name[TSDB_TOPIC_FNAME_LEN];
+  int8_t  igExists;
+  int8_t  withTbName;
+  int8_t  withSchema;
+  int8_t  withTag;
+  int8_t  withTagSchema;
+  char*   sql;
+  char*   ast;
+  int64_t subDbUid;
+  char    subscribeDbName[TSDB_DB_NAME_LEN];
 } SCMCreateTopicReq;
 
 int32_t tSerializeSCMCreateTopicReq(void* buf, int32_t bufLen, const SCMCreateTopicReq* pReq);
@@ -1473,8 +1486,12 @@ typedef struct {
 typedef struct {
   float      xFilesFactor;
   int32_t    delay;
-  int8_t     nFuncIds;
+  int32_t    qmsg1Len;
+  int32_t    qmsg2Len;
   func_id_t* pFuncIds;
+  char*      qmsg1;  // not null: pAst1:qmsg1:SRetention1 => trigger aggr task1
+  char*      qmsg2;  // not null: pAst2:qmsg2:SRetention2 => trigger aggr task2
+  int8_t     nFuncIds;
 } SRSmaParam;
 
 typedef struct SVCreateTbReq {
@@ -1934,12 +1951,22 @@ static FORCE_INLINE void* taosDecodeSMqMsg(void* buf, SMqHbMsg* pMsg) {
   return buf;
 }
 
+enum {
+  TOPIC_SUB_TYPE__DB = 1,
+  TOPIC_SUB_TYPE__TABLE,
+};
+
 typedef struct {
   int64_t leftForVer;
   int32_t vgId;
   int64_t oldConsumerId;
   int64_t newConsumerId;
   char    subKey[TSDB_SUBSCRIBE_KEY_LEN];
+  int8_t  subType;
+  int8_t  withTbName;
+  int8_t  withSchema;
+  int8_t  withTag;
+  int8_t  withTagSchema;
   char*   qmsg;
 } SMqRebVgReq;
 
@@ -1950,7 +1977,14 @@ static FORCE_INLINE int32_t tEncodeSMqRebVgReq(void** buf, const SMqRebVgReq* pR
   tlen += taosEncodeFixedI64(buf, pReq->oldConsumerId);
   tlen += taosEncodeFixedI64(buf, pReq->newConsumerId);
   tlen += taosEncodeString(buf, pReq->subKey);
-  tlen += taosEncodeString(buf, pReq->qmsg);
+  tlen += taosEncodeFixedI8(buf, pReq->subType);
+  tlen += taosEncodeFixedI8(buf, pReq->withTbName);
+  tlen += taosEncodeFixedI8(buf, pReq->withSchema);
+  tlen += taosEncodeFixedI8(buf, pReq->withTag);
+  tlen += taosEncodeFixedI8(buf, pReq->withTagSchema);
+  if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {
+    tlen += taosEncodeString(buf, pReq->qmsg);
+  }
   return tlen;
 }
 
@@ -1960,7 +1994,14 @@ static FORCE_INLINE void* tDecodeSMqRebVgReq(const void* buf, SMqRebVgReq* pReq)
   buf = taosDecodeFixedI64(buf, &pReq->oldConsumerId);
   buf = taosDecodeFixedI64(buf, &pReq->newConsumerId);
   buf = taosDecodeStringTo(buf, pReq->subKey);
-  buf = taosDecodeString(buf, &pReq->qmsg);
+  buf = taosDecodeFixedI8(buf, &pReq->subType);
+  buf = taosDecodeFixedI8(buf, &pReq->withTbName);
+  buf = taosDecodeFixedI8(buf, &pReq->withSchema);
+  buf = taosDecodeFixedI8(buf, &pReq->withTag);
+  buf = taosDecodeFixedI8(buf, &pReq->withTagSchema);
+  if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {
+    buf = taosDecodeString(buf, &pReq->qmsg);
+  }
   return (void*)buf;
 }
 
@@ -2300,9 +2341,10 @@ static FORCE_INLINE void tdDestroyTSmaWrapper(STSmaWrapper* pSW) {
   }
 }
 
-static FORCE_INLINE void tdFreeTSmaWrapper(STSmaWrapper* pSW) {
+static FORCE_INLINE void* tdFreeTSmaWrapper(STSmaWrapper* pSW) {
   tdDestroyTSmaWrapper(pSW);
-  taosMemoryFreeClear(pSW);
+  taosMemoryFree(pSW);
+  return NULL;
 }
 
 static FORCE_INLINE int32_t tEncodeTSma(void** buf, const STSma* pSma) {
@@ -2690,6 +2732,7 @@ static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* p
   }
   return buf;
 }
+
 #pragma pack(pop)
 
 #ifdef __cplusplus
diff --git a/include/libs/function/function.h b/include/libs/function/function.h
index eafe64c294..68fc3be617 100644
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@@ -166,6 +166,7 @@ typedef struct SInputColumnInfoData {
   SColumnInfoData  *pPTS;           // primary timestamp column
   SColumnInfoData **pData;
   SColumnDataAgg  **pColumnDataAgg;
+  uint64_t          uid;            // table uid
 } SInputColumnInfoData;
 
 // sql function runtime context
@@ -191,7 +192,7 @@ typedef struct SqlFunctionCtx {
   int16_t          functionId;    // function id
   char *           pOutput;       // final result output buffer, point to sdata->data
   int32_t          numOfParams;
-  SVariant         param[4];      // input parameter, e.g., top(k, 20), the number of results for top query is kept in param
+  SFunctParam     *param;         // input parameter, e.g., top(k, 20), the number of results for top query is kept in param
   int64_t         *ptsList;       // corresponding timestamp array list
   SColumnInfoData *pTsOutput;     // corresponding output buffer for timestamp of each result, e.g., top/bottom*/
   int32_t          offset;
diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index 321ca13f0e..a47bf4caee 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -48,6 +48,9 @@ extern "C" {
     (NULL == cell1 ? (node1 = NULL, false) : (node1 = cell1->pNode, true)), (NULL == cell2 ? (node2 = NULL, false) : (node2 = cell2->pNode, true)), (node1 != NULL && node2 != NULL); \
     cell1 = cell1->pNext, cell2 = cell2->pNext)
 
+#define REPLACE_LIST1_NODE(newNode) cell1->pNode = (SNode*)(newNode)
+#define REPLACE_LIST2_NODE(newNode) cell2->pNode = (SNode*)(newNode)
+
 #define FOREACH_FOR_REWRITE(node, list)	\
   for (SListCell* cell = (NULL != (list) ? (list)->pHead : NULL); (NULL != cell ? (node = &(cell->pNode), true) : (node = NULL, false)); cell = cell->pNext)
 
diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index 01e03a983d..b4a290cbfc 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -155,7 +155,6 @@ typedef struct SLogicSubplan {
 
 typedef struct SQueryLogicPlan {
   ENodeType type;
-  int32_t totalLevel;
   SNodeList* pTopSubplans;
 } SQueryLogicPlan;
 
diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 93282f658a..143224d8f5 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -229,10 +229,10 @@ typedef struct SFillNode {
 typedef struct SSelectStmt {
   ENodeType type; // QUERY_NODE_SELECT_STMT
   bool isDistinct;
-  SNodeList* pProjectionList; // SNode
+  SNodeList* pProjectionList;
   SNode* pFromTable;
   SNode* pWhere;
-  SNodeList* pPartitionByList; // SNode
+  SNodeList* pPartitionByList;
   SNode* pWindow;
   SNodeList* pGroupByList; // SGroupingSetNode
   SNode* pHaving;
@@ -245,12 +245,14 @@ typedef struct SSelectStmt {
 } SSelectStmt;
 
 typedef enum ESetOperatorType {
-  SET_OP_TYPE_UNION_ALL = 1
+  SET_OP_TYPE_UNION_ALL = 1,
+  SET_OP_TYPE_UNION
 } ESetOperatorType;
 
 typedef struct SSetOperator {
   ENodeType type; // QUERY_NODE_SET_OPERATOR
   ESetOperatorType opType;
+  SNodeList* pProjectionList;
   SNode* pLeft;
   SNode* pRight;
   SNodeList* pOrderByList; // SOrderByExprNode
diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h
index eba70b8098..851d4d63c5 100644
--- a/include/libs/planner/planner.h
+++ b/include/libs/planner/planner.h
@@ -30,6 +30,7 @@ typedef struct SPlanContext {
   SNode* pAstRoot;
   bool topicQuery;
   bool streamQuery;
+  bool rSmaQuery;
   bool showRewrite;
   int8_t triggerType;
   int64_t watermark;
diff --git a/include/libs/transport/trpc.h b/include/libs/transport/trpc.h
index 3e2f596784..ab26cfc155 100644
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@@ -54,12 +54,13 @@ typedef struct {
   uint16_t clientPort;
   SRpcMsg  rpcMsg;
   int32_t  rspLen;
-  void    *pRsp;
-  void    *pNode;
+  void *   pRsp;
+  void *   pNode;
 } SNodeMsg;
 
 typedef void (*RpcCfp)(void *parent, SRpcMsg *, SEpSet *);
 typedef int (*RpcAfp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
+typedef int (*RpcRfp)(void *parent, SRpcMsg *, SEpSet *);
 
 typedef struct SRpcInit {
   uint16_t localPort;     // local port
@@ -80,22 +81,25 @@ typedef struct SRpcInit {
   RpcCfp cfp;
 
   // call back to retrieve the client auth info, for server app only
-  RpcAfp afp;;
+  RpcAfp afp;
+
+  // user defined retry func
+  RpcRfp rfp;
 
   void *parent;
 } SRpcInit;
 
 typedef struct {
-  void     *val;
+  void *val;
   int32_t (*clone)(void *src, void **dst);
-  void    (*freeFunc)(const void *arg);
+  void (*freeFunc)(const void *arg);
 } SRpcCtxVal;
 
 typedef struct {
-  int32_t   msgType;
-  void     *val;
+  int32_t msgType;
+  void *  val;
   int32_t (*clone)(void *src, void **dst);
-  void    (*freeFunc)(const void *arg);
+  void (*freeFunc)(const void *arg);
 } SRpcBrokenlinkVal;
 
 typedef struct {
diff --git a/include/os/osEnv.h b/include/os/osEnv.h
index 14d50858b7..a3f92a0b29 100644
--- a/include/os/osEnv.h
+++ b/include/os/osEnv.h
@@ -34,6 +34,7 @@ extern int64_t         tsOpenMax;
 extern int64_t         tsStreamMax;
 extern float           tsNumOfCores;
 extern int64_t         tsTotalMemoryKB;
+extern char*           tsProcPath;
 
 extern char configDir[];
 extern char tsDataDir[];
diff --git a/include/util/talgo.h b/include/util/talgo.h
index ebddce62a8..3ce2652608 100644
--- a/include/util/talgo.h
+++ b/include/util/talgo.h
@@ -82,7 +82,7 @@ void *taosbsearch(const void *key, const void *base, int64_t nmemb, int64_t size
  * @return
  */
 void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar,
-                    __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
+                    __ext_compar_fn_t compar, char* buf, bool maxroot);
 
 /**
  * sort heap to make sure it is a max/min root heap
@@ -98,7 +98,7 @@ void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const
  * @return
  */
 void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar,
-                  const void *parswap, __ext_swap_fn_t swap, bool maxroot);
+                  bool maxroot);
 
 #ifdef __cplusplus
 }
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index e04ff2730a..215e83c7d4 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -614,6 +614,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INTER_SLIDING_TOO_BIG     TAOS_DEF_ERROR_CODE(0, 0x2631)
 #define TSDB_CODE_PAR_INTER_SLIDING_TOO_SMALL   TAOS_DEF_ERROR_CODE(0, 0x2632)
 #define TSDB_CODE_PAR_ONLY_ONE_JSON_TAG         TAOS_DEF_ERROR_CODE(0, 0x2633)
+#define TSDB_CODE_PAR_INCORRECT_NUM_OF_COL      TAOS_DEF_ERROR_CODE(0, 0x2634)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index 35932cc13e..814caf330a 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -219,6 +219,7 @@ void    doSetOneRowPtr(SReqResultInfo* pResultInfo);
 void    setResPrecision(SReqResultInfo* pResInfo, int32_t precision);
 int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4);
 void    setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
+void    doFreeReqResultInfo(SReqResultInfo* pResInfo);
 
 static FORCE_INLINE SReqResultInfo* tmqGetCurResInfo(TAOS_RES* res) {
   SMqRspObj* msg = (SMqRspObj*)res;
@@ -306,7 +307,6 @@ void hbMgrInitMqHbRspHandle();
 
 SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code, bool keepQuery);
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 0b75e3a30b..9a34334466 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -30,15 +30,15 @@
 #define TSC_VAR_RELEASED    0
 
 SAppInfo appInfo;
-int32_t  clientReqRefPool  = -1;
+int32_t  clientReqRefPool = -1;
 int32_t  clientConnRefPool = -1;
 
-static TdThreadOnce   tscinit = PTHREAD_ONCE_INIT;
-volatile int32_t      tscInitRes = 0;
+static TdThreadOnce tscinit = PTHREAD_ONCE_INIT;
+volatile int32_t    tscInitRes = 0;
 
 static void registerRequest(SRequestObj *pRequest) {
   STscObj *pTscObj = acquireTscObj(pRequest->pTscObj->id);
-  
+
   assert(pTscObj != NULL);
 
   // connection has been released already, abort creating request.
@@ -49,8 +49,8 @@ static void registerRequest(SRequestObj *pRequest) {
   if (pTscObj->pAppInfo) {
     SInstanceSummary *pSummary = &pTscObj->pAppInfo->summary;
 
-    int32_t total = atomic_add_fetch_64((int64_t*)&pSummary->totalRequests, 1);
-    int32_t currentInst = atomic_add_fetch_64((int64_t*)&pSummary->currentRequests, 1);
+    int32_t total = atomic_add_fetch_64((int64_t *)&pSummary->totalRequests, 1);
+    int32_t currentInst = atomic_add_fetch_64((int64_t *)&pSummary->currentRequests, 1);
     tscDebug("0x%" PRIx64 " new Request from connObj:0x%" PRIx64
              ", current:%d, app current:%d, total:%d, reqId:0x%" PRIx64,
              pRequest->self, pRequest->pTscObj->id, num, currentInst, total, pRequest->requestId);
@@ -60,16 +60,16 @@ static void registerRequest(SRequestObj *pRequest) {
 static void deregisterRequest(SRequestObj *pRequest) {
   assert(pRequest != NULL);
 
-  STscObj *         pTscObj = pRequest->pTscObj;
+  STscObj          *pTscObj = pRequest->pTscObj;
   SInstanceSummary *pActivity = &pTscObj->pAppInfo->summary;
 
-  int32_t currentInst = atomic_sub_fetch_64((int64_t*)&pActivity->currentRequests, 1);
+  int32_t currentInst = atomic_sub_fetch_64((int64_t *)&pActivity->currentRequests, 1);
   int32_t num = atomic_sub_fetch_32(&pTscObj->numOfReqs, 1);
 
   int64_t duration = taosGetTimestampUs() - pRequest->metric.start;
   tscDebug("0x%" PRIx64 " free Request from connObj: 0x%" PRIx64 ", reqId:0x%" PRIx64 " elapsed:%" PRIu64
            " ms, current:%d, app current:%d",
-           pRequest->self, pTscObj->id, pRequest->requestId, duration/1000, num, currentInst);
+           pRequest->self, pTscObj->id, pRequest->requestId, duration / 1000, num, currentInst);
   releaseTscObj(pTscObj->id);
 }
 
@@ -109,12 +109,12 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
 }
 
 void closeAllRequests(SHashObj *pRequests) {
-  void   *pIter = taosHashIterate(pRequests, NULL);
+  void *pIter = taosHashIterate(pRequests, NULL);
   while (pIter != NULL) {
     int64_t *rid = pIter;
 
-    releaseRequest(*rid);    
-    
+    releaseRequest(*rid);
+
     pIter = taosHashIterate(pRequests, pIter);
   }
 }
@@ -144,7 +144,7 @@ void *createTscObj(const char *user, const char *auth, const char *db, SAppInstI
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
   }
-  
+
   pObj->pAppInfo = pAppInfo;
   tstrncpy(pObj->user, user, sizeof(pObj->user));
   memcpy(pObj->pass, auth, TSDB_PASSWORD_LEN);
@@ -160,13 +160,9 @@ void *createTscObj(const char *user, const char *auth, const char *db, SAppInstI
   return pObj;
 }
 
-STscObj *acquireTscObj(int64_t rid) {
-  return (STscObj *)taosAcquireRef(clientConnRefPool, rid);
-}
+STscObj *acquireTscObj(int64_t rid) { return (STscObj *)taosAcquireRef(clientConnRefPool, rid); }
 
-int32_t releaseTscObj(int64_t rid) {
-  return taosReleaseRef(clientConnRefPool, rid);
-}
+int32_t releaseTscObj(int64_t rid) { return taosReleaseRef(clientConnRefPool, rid); }
 
 void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t type) {
   assert(pObj != NULL);
@@ -190,11 +186,11 @@ void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t ty
   tsem_init(&pRequest->body.rspSem, 0, 0);
 
   registerRequest(pRequest);
-    
+
   return pRequest;
 }
 
-static void doFreeReqResultInfo(SReqResultInfo *pResInfo) {
+void doFreeReqResultInfo(SReqResultInfo *pResInfo) {
   taosMemoryFreeClear(pResInfo->pRspMsg);
   taosMemoryFreeClear(pResInfo->length);
   taosMemoryFreeClear(pResInfo->row);
@@ -217,7 +213,7 @@ static void doDestroyRequest(void *p) {
   assert(RID_VALID(pRequest->self));
 
   taosHashRemove(pRequest->pTscObj->pRequests, &pRequest->self, sizeof(pRequest->self));
-  
+
   taosMemoryFreeClear(pRequest->msgBuf);
   taosMemoryFreeClear(pRequest->sqlstr);
   taosMemoryFreeClear(pRequest->pDb);
@@ -244,14 +240,9 @@ void destroyRequest(SRequestObj *pRequest) {
   taosRemoveRef(clientReqRefPool, pRequest->self);
 }
 
-SRequestObj *acquireRequest(int64_t rid) {
-  return (SRequestObj *)taosAcquireRef(clientReqRefPool, rid);
-}
-
-int32_t releaseRequest(int64_t rid) {
-  return taosReleaseRef(clientReqRefPool, rid);
-}
+SRequestObj *acquireRequest(int64_t rid) { return (SRequestObj *)taosAcquireRef(clientReqRefPool, rid); }
 
+int32_t releaseRequest(int64_t rid) { return taosReleaseRef(clientReqRefPool, rid); }
 
 void taos_init_imp(void) {
   // In the APIs of other program language, taos_cleanup is not available yet.
@@ -380,7 +371,7 @@ uint64_t generateRequestId() {
   }
 
   uint64_t id = 0;
-  
+
   while (true) {
     int64_t  ts = taosGetTimestampMs();
     uint64_t pid = taosGetPId();
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 0011c8baf3..10edb38bf1 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -146,7 +146,8 @@ int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj*
   (*pRequest)->sqlstr[sqlLen] = 0;
   (*pRequest)->sqlLen = sqlLen;
 
-  if (taosHashPut(pTscObj->pRequests, &(*pRequest)->self, sizeof((*pRequest)->self), &(*pRequest)->self, sizeof((*pRequest)->self))) {
+  if (taosHashPut(pTscObj->pRequests, &(*pRequest)->self, sizeof((*pRequest)->self), &(*pRequest)->self,
+                  sizeof((*pRequest)->self))) {
     destroyRequest(*pRequest);
     *pRequest = NULL;
     tscError("put request to request hash failed");
@@ -263,7 +264,8 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
 }
 
 void setResPrecision(SReqResultInfo* pResInfo, int32_t precision) {
-  if (precision != TSDB_TIME_PRECISION_MILLI && precision != TSDB_TIME_PRECISION_MICRO && precision != TSDB_TIME_PRECISION_NANO) {
+  if (precision != TSDB_TIME_PRECISION_MILLI && precision != TSDB_TIME_PRECISION_MICRO &&
+      precision != TSDB_TIME_PRECISION_NANO) {
     return;
   }
 
@@ -275,7 +277,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
 
   SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
   int32_t      code = schedulerExecJob(pTransporter, pNodeList, pDag, &pRequest->body.queryJob, pRequest->sqlstr,
-                                       pRequest->metric.start, &res);
+                                  pRequest->metric.start, &res);
   if (code != TSDB_CODE_SUCCESS) {
     if (pRequest->body.queryJob != 0) {
       schedulerFreeJob(pRequest->body.queryJob);
@@ -300,7 +302,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
 }
 
 SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code, bool keepQuery) {
-  SArray*      pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
+  SArray* pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
 
   if (TSDB_CODE_SUCCESS == code) {
     switch (pQuery->execMode) {
@@ -328,7 +330,7 @@ SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code
   if (!keepQuery) {
     qDestroyQuery(pQuery);
   }
-  
+
   if (NULL != pRequest && TSDB_CODE_SUCCESS != code) {
     pRequest->code = terrno;
   }
@@ -336,7 +338,6 @@ SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code
   return pRequest;
 }
 
-
 SRequestObj* launchQuery(STscObj* pTscObj, const char* sql, int sqlLen) {
   SRequestObj* pRequest = NULL;
   SQuery*      pQuery = NULL;
@@ -522,6 +523,8 @@ static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest, int8_t connType) {
   connectReq.pid = htonl(appInfo.pid);
   connectReq.startTime = htobe64(appInfo.startTime);
   tstrncpy(connectReq.app, appInfo.appName, sizeof(connectReq.app));
+  tstrncpy(connectReq.user, pObj->user, sizeof(connectReq.user));
+  tstrncpy(connectReq.passwd, pObj->pass, sizeof(connectReq.passwd));
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
   void*   pReq = taosMemoryMalloc(contLen);
@@ -726,7 +729,7 @@ static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int
           int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(p));
           ASSERT(len <= bytes);
           ASSERT((p + len) < (pResultInfo->convertBuf[i] + colLength[i]));
-          
+
           varDataSetLen(p, len);
           pCol->offset[j] = (p - pResultInfo->convertBuf[i]);
           p += (len + VARSTR_HEADER_SIZE);
@@ -744,51 +747,55 @@ static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int
       }
 
       pResultInfo->convertBuf[i] = p;
-      int32_t len = 0;
+      int32_t        len = 0;
       SResultColumn* pCol = &pResultInfo->pCol[i];
       for (int32_t j = 0; j < numOfRows; ++j) {
         if (pCol->offset[j] != -1) {
           char* pStart = pCol->offset[j] + pCol->pData;
 
           int32_t jsonInnerType = *pStart;
-          char *jsonInnerData = pStart + CHAR_BYTES;
-          char dst[TSDB_MAX_JSON_TAG_LEN] = {0};
-          if(jsonInnerType == TSDB_DATA_TYPE_NULL){
+          char*   jsonInnerData = pStart + CHAR_BYTES;
+          char    dst[TSDB_MAX_JSON_TAG_LEN] = {0};
+          if (jsonInnerType == TSDB_DATA_TYPE_NULL) {
             sprintf(varDataVal(dst), "%s", TSDB_DATA_NULL_STR_L);
             varDataSetLen(dst, strlen(varDataVal(dst)));
-          }else if(jsonInnerType == TSDB_DATA_TYPE_JSON){
-            int32_t length = taosUcs4ToMbs((TdUcs4 *)varDataVal(jsonInnerData), varDataLen(jsonInnerData), varDataVal(dst));
+          } else if (jsonInnerType == TSDB_DATA_TYPE_JSON) {
+            int32_t length =
+                taosUcs4ToMbs((TdUcs4*)varDataVal(jsonInnerData), varDataLen(jsonInnerData), varDataVal(dst));
 
             if (length <= 0) {
-              tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, varDataVal(jsonInnerData));
+              tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset,
+                       varDataVal(jsonInnerData));
               length = 0;
             }
             varDataSetLen(dst, length);
-          }else if (jsonInnerType == TSDB_DATA_TYPE_NCHAR) {   // value -> "value"
+          } else if (jsonInnerType == TSDB_DATA_TYPE_NCHAR) {  // value -> "value"
             *(char*)varDataVal(dst) = '\"';
-            int32_t length = taosUcs4ToMbs((TdUcs4 *)varDataVal(jsonInnerData), varDataLen(jsonInnerData), varDataVal(dst) + CHAR_BYTES);
+            int32_t length = taosUcs4ToMbs((TdUcs4*)varDataVal(jsonInnerData), varDataLen(jsonInnerData),
+                                           varDataVal(dst) + CHAR_BYTES);
             if (length <= 0) {
-              tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, varDataVal(jsonInnerData));
+              tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset,
+                       varDataVal(jsonInnerData));
               length = 0;
             }
-            varDataSetLen(dst, length + CHAR_BYTES*2);
+            varDataSetLen(dst, length + CHAR_BYTES * 2);
             *(char*)(varDataVal(dst), length + CHAR_BYTES) = '\"';
-          }else if(jsonInnerType == TSDB_DATA_TYPE_DOUBLE){
+          } else if (jsonInnerType == TSDB_DATA_TYPE_DOUBLE) {
             double jsonVd = *(double*)(jsonInnerData);
             sprintf(varDataVal(dst), "%.9lf", jsonVd);
             varDataSetLen(dst, strlen(varDataVal(dst)));
-          }else if(jsonInnerType == TSDB_DATA_TYPE_BIGINT){
+          } else if (jsonInnerType == TSDB_DATA_TYPE_BIGINT) {
             int64_t jsonVd = *(int64_t*)(jsonInnerData);
             sprintf(varDataVal(dst), "%" PRId64, jsonVd);
             varDataSetLen(dst, strlen(varDataVal(dst)));
-          }else if(jsonInnerType == TSDB_DATA_TYPE_BOOL){
-            sprintf(varDataVal(dst), "%s", (*((char *)jsonInnerData) == 1) ? "true" : "false");
+          } else if (jsonInnerType == TSDB_DATA_TYPE_BOOL) {
+            sprintf(varDataVal(dst), "%s", (*((char*)jsonInnerData) == 1) ? "true" : "false");
             varDataSetLen(dst, strlen(varDataVal(dst)));
-          }else {
+          } else {
             ASSERT(0);
           }
 
-          if(len + varDataTLen(dst) > colLength[i]){
+          if (len + varDataTLen(dst) > colLength[i]) {
             p = taosMemoryRealloc(pResultInfo->convertBuf[i], len + varDataTLen(dst));
             if (p == NULL) {
               return TSDB_CODE_OUT_OF_MEMORY;
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index 99cbd208ee..27efcee76e 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -135,6 +135,16 @@ void taos_free_result(TAOS_RES *res) {
   if (TD_RES_QUERY(res)) {
     SRequestObj *pRequest = (SRequestObj *)res;
     destroyRequest(pRequest);
+  } else if (TD_RES_TMQ(res)) {
+    SMqRspObj *pRsp = (SMqRspObj *)res;
+    if (pRsp->rsp.blockData) taosArrayDestroyP(pRsp->rsp.blockData, taosMemoryFree);
+    if (pRsp->rsp.blockDataLen) taosArrayDestroy(pRsp->rsp.blockDataLen);
+    if (pRsp->rsp.blockSchema) taosArrayDestroy(pRsp->rsp.blockSchema);
+    if (pRsp->rsp.blockTbName) taosArrayDestroy(pRsp->rsp.blockTbName);
+    if (pRsp->rsp.blockTags) taosArrayDestroy(pRsp->rsp.blockTags);
+    if (pRsp->rsp.blockTagSchema) taosArrayDestroy(pRsp->rsp.blockTagSchema);
+    pRsp->resInfo.pRspMsg = NULL;
+    doFreeReqResultInfo(&pRsp->resInfo);
   }
 }
 
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index 53b0fec8ff..8e8c62cd94 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -662,7 +662,7 @@ TEST(testCase, agg_query_tables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "select count(*) from tu");
+  pRes = taos_query(pConn, "select now() from m1");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c
index f2a5a98d96..2ed08ac81f 100644
--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
@@ -110,7 +110,7 @@ void *tdDecodeSchema(void *buf, STSchema **pRSchema) {
 
   for (int i = 0; i < numOfCols; i++) {
     col_type_t  type = 0;
-    int8_t      sma = TSDB_BSMA_TYPE_NONE;
+    int8_t      sma = 0;
     col_id_t    colId = 0;
     col_bytes_t bytes = 0;
     buf = taosDecodeFixedI8(buf, &type);
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index aa6beb49ae..0ea196f1a1 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -434,6 +434,15 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
         for (int8_t i = 0; i < param->nFuncIds; ++i) {
           tlen += taosEncodeFixedI32(buf, param->pFuncIds[i]);
         }
+        tlen += taosEncodeFixedI32(buf, param->qmsg1Len);
+        if (param->qmsg1Len > 0) {
+          tlen += taosEncodeString(buf, param->qmsg1);
+        }
+
+        tlen += taosEncodeFixedI32(buf, param->qmsg2Len);
+        if (param->qmsg2Len > 0) {
+          tlen += taosEncodeString(buf, param->qmsg2);
+        }
       }
       break;
     case TD_CHILD_TABLE:
@@ -496,18 +505,25 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pTagSchema[i].name);
       }
       if (pReq->rollup) {
-        pReq->stbCfg.pRSmaParam = (SRSmaParam *)taosMemoryMalloc(sizeof(SRSmaParam));
+        pReq->stbCfg.pRSmaParam = (SRSmaParam *)taosMemoryCalloc(1, sizeof(SRSmaParam));
         SRSmaParam *param = pReq->stbCfg.pRSmaParam;
         buf = taosDecodeBinaryTo(buf, (void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
         buf = taosDecodeFixedI32(buf, &param->delay);
         buf = taosDecodeFixedI8(buf, &param->nFuncIds);
         if (param->nFuncIds > 0) {
-          param->pFuncIds = (func_id_t *)taosMemoryMalloc(param->nFuncIds * sizeof(func_id_t));
+          param->pFuncIds = (func_id_t *)taosMemoryCalloc(param->nFuncIds, sizeof(func_id_t));
           for (int8_t i = 0; i < param->nFuncIds; ++i) {
             buf = taosDecodeFixedI32(buf, param->pFuncIds + i);
           }
-        } else {
-          param->pFuncIds = NULL;
+        }
+        buf = taosDecodeFixedI32(buf, &param->qmsg1Len);
+        if (param->qmsg1Len > 0) {
+          buf = taosDecodeString(buf, &param->qmsg1);
+        }
+
+        buf = taosDecodeFixedI32(buf, &param->qmsg2Len);
+        if (param->qmsg2Len > 0) {
+          buf = taosDecodeString(buf, &param->qmsg2);
         }
       } else {
         pReq->stbCfg.pRSmaParam = NULL;
@@ -828,6 +844,27 @@ void tFreeSMAltertbReq(SMAltertbReq *pReq) {
   taosArrayDestroy(pReq->pFields);
   pReq->pFields = NULL;
 }
+int32_t tSerializeSMEpSet(void *buf, int32_t bufLen, SMEpSet *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeSEpSet(&encoder, &pReq->epSet) < 0) return -1;
+
+  tEndEncode(&encoder);
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+int32_t tDeserializeSMEpSet(void *buf, int32_t bufLen, SMEpSet *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeSEpSet(&decoder, &pReq->epSet) < 0) return -1;
+
+  tEndDecode(&decoder);
+  tCoderClear(&decoder);
+  return 0;
+}
 
 int32_t tSerializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pReq) {
   SCoder encoder = {0};
@@ -2425,7 +2462,6 @@ int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq
 
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->type) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
   tEndEncode(&encoder);
@@ -2441,7 +2477,6 @@ int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableR
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->type) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
   tEndDecode(&decoder);
@@ -2696,6 +2731,10 @@ int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTo
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->withTbName) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->withSchema) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->withTag) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->withTagSchema) < 0) return -1;
   if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
   if (tEncodeI32(&encoder, astLen) < 0) return -1;
   if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
@@ -2718,6 +2757,10 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->withTbName) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->withSchema) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->withTag) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->withTagSchema) < 0) return -1;
   if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
   if (tDecodeI32(&decoder, &astLen) < 0) return -1;
 
@@ -2778,6 +2821,8 @@ int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
   if (tEncodeI32(&encoder, pReq->pid) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->app) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->passwd) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->startTime) < 0) return -1;
   tEndEncode(&encoder);
 
@@ -2795,6 +2840,8 @@ int32_t tDeserializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
   if (tDecodeI32(&decoder, &pReq->pid) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->app) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->passwd) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->startTime) < 0) return -1;
   tEndDecode(&decoder);
 
@@ -3054,7 +3101,6 @@ int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq
   return 0;
 }
 
-
 int32_t tSerializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -3074,7 +3120,7 @@ int32_t tSerializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq
     SReplica *pReplica = &pReq->replicas[i];
     if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
   }
-  
+
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -3107,7 +3153,6 @@ int32_t tDeserializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pR
   return 0;
 }
 
-
 int32_t tSerializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
diff --git a/source/dnode/mgmt/implement/src/dmHandle.c b/source/dnode/mgmt/implement/src/dmHandle.c
index dd221f8404..376f589acd 100644
--- a/source/dnode/mgmt/implement/src/dmHandle.c
+++ b/source/dnode/mgmt/implement/src/dmHandle.c
@@ -216,6 +216,126 @@ static void dmStopMgmt(SMgmtWrapper *pWrapper) {
   dmStopStatusThread(pWrapper->pDnode);
 }
 
+static int32_t dmSpawnUdfd(SDnode *pDnode);
+
+void dmUdfdExit(uv_process_t *process, int64_t exitStatus, int termSignal) {
+  dInfo("udfd process exited with status %" PRId64 ", signal %d", exitStatus, termSignal);
+  uv_close((uv_handle_t*)process, NULL);
+  SDnode *pDnode = process->data;
+  SUdfdData *pData = &pDnode->udfdData;
+  if (atomic_load_8(&pData->stopping) != 0) {
+    dDebug("udfd process exit due to stopping");
+  } else {
+    uv_close((uv_handle_t*)&pData->ctrlPipe, NULL);
+    dmSpawnUdfd(pDnode);
+  }
+}
+
+static int32_t dmSpawnUdfd(SDnode *pDnode) {
+  dInfo("dnode start spawning udfd");
+  uv_process_options_t options = {0};
+
+  char path[PATH_MAX] = {0};
+  if (tsProcPath == NULL) {
+    path[0] = '.';
+  } else {
+    strncpy(path, tsProcPath, strlen(tsProcPath));
+    taosDirName(path);
+  }
+  strcat(path, "/udfd");
+  char* argsUdfd[] = {path, "-c", configDir, NULL};
+  options.args = argsUdfd;
+  options.file = path;
+
+  options.exit_cb = dmUdfdExit;
+  SUdfdData *pData = &pDnode->udfdData;
+  uv_pipe_init(&pData->loop, &pData->ctrlPipe, 1);
+
+  uv_stdio_container_t child_stdio[3];
+  child_stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
+  child_stdio[0].data.stream = (uv_stream_t*) &pData->ctrlPipe;
+  child_stdio[1].flags = UV_IGNORE;
+  child_stdio[2].flags = UV_INHERIT_FD;
+  child_stdio[2].data.fd = 2;
+  options.stdio_count = 3;
+  options.stdio = child_stdio;
+
+  char dnodeIdEnvItem[32] = {0};
+  char thrdPoolSizeEnvItem[32] = {0};
+  snprintf(dnodeIdEnvItem, 32, "%s=%d", "DNODE_ID", pDnode->data.dnodeId);
+  float numCpuCores = 4;
+  taosGetCpuCores(&numCpuCores);
+  snprintf(thrdPoolSizeEnvItem,32,  "%s=%d", "UV_THREADPOOL_SIZE", (int)numCpuCores*2);
+  char* envUdfd[] = {dnodeIdEnvItem, thrdPoolSizeEnvItem, NULL};
+  options.env = envUdfd;
+
+  int err = uv_spawn(&pData->loop, &pData->process, &options);
+  pData->process.data = (void*)pDnode;
+
+  if (err != 0) {
+    dError("can not spawn udfd. path: %s, error: %s", path, uv_strerror(err));
+  }
+  return err;
+}
+
+static void dmUdfdCloseWalkCb(uv_handle_t* handle, void* arg) {
+  if (!uv_is_closing(handle)) {
+    uv_close(handle, NULL);
+  }
+}
+
+void dmWatchUdfd(void *args) {
+  SDnode *pDnode = args;
+  SUdfdData *pData = &pDnode->udfdData;
+  uv_loop_init(&pData->loop);
+  int32_t err = dmSpawnUdfd(pDnode);
+  atomic_store_32(&pData->spawnErr, err);
+  uv_barrier_wait(&pData->barrier);
+  uv_run(&pData->loop, UV_RUN_DEFAULT);
+  err = uv_loop_close(&pData->loop);
+  while (err == UV_EBUSY) {
+    uv_walk(&pData->loop, dmUdfdCloseWalkCb, NULL);
+    uv_run(&pData->loop, UV_RUN_DEFAULT);
+    err = uv_loop_close(&pData->loop);
+  }
+  return;
+}
+
+int32_t dmStartUdfd(SDnode *pDnode) {
+  SUdfdData *pData = &pDnode->udfdData;
+  if (pData->startCalled) {
+    dInfo("dnode-mgmt start udfd already called");
+    return 0;
+  }
+  uv_barrier_init(&pData->barrier, 2);
+  pData->stopping = 0;
+  uv_thread_create(&pData->thread, dmWatchUdfd, pDnode);
+  uv_barrier_wait(&pData->barrier);
+  pData->startCalled = true;
+  pData->needCleanUp = true;
+  return pData->spawnErr;
+}
+
+int32_t dmStopUdfd(SDnode *pDnode) {
+  dInfo("dnode-mgmt to stop udfd. need cleanup: %d, spawn err: %d",
+        pDnode->udfdData.needCleanUp, pDnode->udfdData.spawnErr);
+  SUdfdData *pData = &pDnode->udfdData;
+  if (!pData->needCleanUp) {
+    return 0;
+  }
+  atomic_store_8(&pData->stopping, 1);
+
+  uv_barrier_destroy(&pData->barrier);
+  if (pData->spawnErr == 0) {
+    uv_process_kill(&pData->process, SIGINT);
+  }
+  uv_stop(&pData->loop);
+  uv_thread_join(&pData->thread);
+
+  atomic_store_8(&pData->stopping, 0);
+  return 0;
+}
+
 static int32_t dmInitMgmt(SMgmtWrapper *pWrapper) {
   dInfo("dnode-mgmt start to init");
   SDnode *pDnode = pWrapper->pDnode;
@@ -247,6 +367,10 @@ static int32_t dmInitMgmt(SMgmtWrapper *pWrapper) {
   }
   dmReportStartup(pDnode, "dnode-transport", "initialized");
 
+  if (dmStartUdfd(pDnode) != 0) {
+    dError("failed to start udfd");
+  }
+
   dInfo("dnode-mgmt is initialized");
   return 0;
 }
@@ -254,6 +378,7 @@ static int32_t dmInitMgmt(SMgmtWrapper *pWrapper) {
 static void dmCleanupMgmt(SMgmtWrapper *pWrapper) {
   dInfo("dnode-mgmt start to clean up");
   SDnode *pDnode = pWrapper->pDnode;
+  dmStopUdfd(pDnode);
   dmStopWorker(pDnode);
 
   taosWLockLatch(&pDnode->data.latch);
diff --git a/source/dnode/mgmt/implement/src/dmTransport.c b/source/dnode/mgmt/implement/src/dmTransport.c
index 7cfec917b1..a574d802f9 100644
--- a/source/dnode/mgmt/implement/src/dmTransport.c
+++ b/source/dnode/mgmt/implement/src/dmTransport.c
@@ -119,10 +119,10 @@ _OVER:
 }
 
 static void dmProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SDnodeTrans  *pTrans = &pDnode->trans;
+  SDnodeTrans * pTrans = &pDnode->trans;
   tmsg_t        msgType = pMsg->msgType;
   bool          isReq = msgType & 1u;
-  SMsgHandle   *pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
+  SMsgHandle *  pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
   SMgmtWrapper *pWrapper = pHandle->pNdWrapper;
 
   if (msgType == TDMT_DND_SERVER_STATUS) {
@@ -443,7 +443,7 @@ static inline int32_t dmRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *s
   SAuthReq authReq = {0};
   tstrncpy(authReq.user, user, TSDB_USER_LEN);
   int32_t contLen = tSerializeSAuthReq(NULL, 0, &authReq);
-  void   *pReq = rpcMallocCont(contLen);
+  void *  pReq = rpcMallocCont(contLen);
   tSerializeSAuthReq(pReq, contLen, &authReq);
 
   SRpcMsg rpcMsg = {.pCont = pReq, .contLen = contLen, .msgType = TDMT_MND_AUTH, .ahandle = (void *)9528};
@@ -523,4 +523,4 @@ SMsgCb dmGetMsgcb(SMgmtWrapper *pWrapper) {
       .pWrapper = pWrapper,
   };
   return msgCb;
-}
\ No newline at end of file
+}
diff --git a/source/dnode/mgmt/interface/inc/dmDef.h b/source/dnode/mgmt/interface/inc/dmDef.h
index e6537dcf73..4f4a2ed349 100644
--- a/source/dnode/mgmt/interface/inc/dmDef.h
+++ b/source/dnode/mgmt/interface/inc/dmDef.h
@@ -16,6 +16,7 @@
 #ifndef _TD_DM_DEF_H_
 #define _TD_DM_DEF_H_
 
+#include "uv.h"
 #include "dmLog.h"
 
 #include "cJSON.h"
@@ -142,6 +143,18 @@ typedef struct {
   char desc[TSDB_STEP_DESC_LEN];
 } SStartupInfo;
 
+typedef struct SUdfdData {
+  bool          startCalled;
+  bool          needCleanUp;
+  uv_loop_t     loop;
+  uv_thread_t   thread;
+  uv_barrier_t  barrier;
+  uv_process_t  process;
+  int           spawnErr;
+  int8_t        stopping;
+  uv_pipe_t     ctrlPipe;
+} SUdfdData;
+
 typedef struct SDnode {
   EDndProcType  ptype;
   EDndNodeType  ntype;
@@ -150,6 +163,7 @@ typedef struct SDnode {
   SStartupInfo  startup;
   SDnodeTrans   trans;
   SDnodeData    data;
+  SUdfdData     udfdData;
   TdThreadMutex mutex;
   SMgmtWrapper  wrappers[NODE_END];
 } SDnode;
diff --git a/source/dnode/mgmt/test/sut/src/sut.cpp b/source/dnode/mgmt/test/sut/src/sut.cpp
index 9b4c479865..cc32f047af 100644
--- a/source/dnode/mgmt/test/sut/src/sut.cpp
+++ b/source/dnode/mgmt/test/sut/src/sut.cpp
@@ -89,7 +89,6 @@ int32_t Testbase::SendShowReq(int8_t showType, const char *tb, const char* db) {
   }
 
   SRetrieveTableReq retrieveReq = {0};
-  retrieveReq.type = showType;
   strcpy(retrieveReq.db, db);
   strcpy(retrieveReq.tb, tb);
 
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index 12710f0d4c..59a00f0eaf 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -391,7 +391,6 @@ typedef struct {
   int16_t        numOfColumns;
   int32_t        rowSize;
   int32_t        numOfRows;
-  int32_t        payloadLen;
   void*          pIter;
   SMnode*        pMnode;
   STableMetaRsp* pMeta;
@@ -418,82 +417,6 @@ typedef struct {
   char    payload[];
 } SSysTableRetrieveObj;
 
-typedef struct {
-  int32_t vgId;  // -1 for unassigned
-  int32_t status;
-  int32_t epoch;
-  SEpSet  epSet;
-  int64_t oldConsumerId;
-  int64_t consumerId;  // -1 for unassigned
-  char*   qmsg;
-} SMqConsumerEp;
-
-static FORCE_INLINE int32_t tEncodeSMqConsumerEp(void** buf, const SMqConsumerEp* pConsumerEp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pConsumerEp->vgId);
-  tlen += taosEncodeFixedI32(buf, pConsumerEp->status);
-  tlen += taosEncodeFixedI32(buf, pConsumerEp->epoch);
-  tlen += taosEncodeSEpSet(buf, &pConsumerEp->epSet);
-  tlen += taosEncodeFixedI64(buf, pConsumerEp->oldConsumerId);
-  tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
-  tlen += taosEncodeString(buf, pConsumerEp->qmsg);
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSMqConsumerEp(void** buf, SMqConsumerEp* pConsumerEp) {
-  buf = taosDecodeFixedI32(buf, &pConsumerEp->vgId);
-  buf = taosDecodeFixedI32(buf, &pConsumerEp->status);
-  buf = taosDecodeFixedI32(buf, &pConsumerEp->epoch);
-  buf = taosDecodeSEpSet(buf, &pConsumerEp->epSet);
-  buf = taosDecodeFixedI64(buf, &pConsumerEp->oldConsumerId);
-  buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
-  buf = taosDecodeString(buf, &pConsumerEp->qmsg);
-  return buf;
-}
-
-static FORCE_INLINE void tDeleteSMqConsumerEp(SMqConsumerEp* pConsumerEp) {
-  if (pConsumerEp) {
-    taosMemoryFreeClear(pConsumerEp->qmsg);
-  }
-}
-
-typedef struct {
-  int64_t consumerId;
-  SArray* vgInfo;  // SArray<SMqConsumerEp>
-} SMqSubConsumer;
-
-static FORCE_INLINE int32_t tEncodeSMqSubConsumer(void** buf, const SMqSubConsumer* pConsumer) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pConsumer->consumerId);
-  int32_t sz = taosArrayGetSize(pConsumer->vgInfo);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqConsumerEp* pCEp = taosArrayGet(pConsumer->vgInfo, i);
-    tlen += tEncodeSMqConsumerEp(buf, pCEp);
-  }
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSMqSubConsumer(void** buf, SMqSubConsumer* pConsumer) {
-  int32_t sz;
-  buf = taosDecodeFixedI64(buf, &pConsumer->consumerId);
-  buf = taosDecodeFixedI32(buf, &sz);
-  pConsumer->vgInfo = taosArrayInit(sz, sizeof(SMqConsumerEp));
-  for (int32_t i = 0; i < sz; i++) {
-    SMqConsumerEp consumerEp;
-    buf = tDecodeSMqConsumerEp(buf, &consumerEp);
-    taosArrayPush(pConsumer->vgInfo, &consumerEp);
-  }
-  return buf;
-}
-
-static FORCE_INLINE void tDeleteSMqSubConsumer(SMqSubConsumer* pSubConsumer) {
-  if (pSubConsumer->vgInfo) {
-    taosArrayDestroyEx(pSubConsumer->vgInfo, (void (*)(void*))tDeleteSMqConsumerEp);
-    pSubConsumer->vgInfo = NULL;
-  }
-}
-
 typedef struct {
   char    key[TSDB_PARTITION_KEY_LEN];
   int64_t offset;
@@ -512,147 +435,21 @@ static FORCE_INLINE void* tDecodeSMqOffsetObj(void* buf, SMqOffsetObj* pOffset)
   return buf;
 }
 
-#if 0
 typedef struct {
-  char    key[TSDB_SUBSCRIBE_KEY_LEN];
-  int32_t status;
-  int32_t vgNum;
-  SArray* consumers;      // SArray<SMqSubConsumer>
-  SArray* lostConsumers;  // SArray<SMqSubConsumer>
-  SArray* unassignedVg;   // SArray<SMqConsumerEp>
-} SMqSubscribeObj;
-
-static FORCE_INLINE SMqSubscribeObj* tNewSubscribeObj() {
-  SMqSubscribeObj* pSub = taosMemoryCalloc(1, sizeof(SMqSubscribeObj));
-  if (pSub == NULL) {
-    return NULL;
-  }
-
-  pSub->consumers = taosArrayInit(0, sizeof(SMqSubConsumer));
-  if (pSub->consumers == NULL) {
-    goto _err;
-  }
-
-  pSub->lostConsumers = taosArrayInit(0, sizeof(SMqSubConsumer));
-  if (pSub->lostConsumers == NULL) {
-    goto _err;
-  }
-
-  pSub->unassignedVg = taosArrayInit(0, sizeof(SMqConsumerEp));
-  if (pSub->unassignedVg == NULL) {
-    goto _err;
-  }
-
-  pSub->key[0] = 0;
-  pSub->vgNum = 0;
-  pSub->status = 0;
-
-  return pSub;
-
-_err:
-  taosMemoryFreeClear(pSub->consumers);
-  taosMemoryFreeClear(pSub->lostConsumers);
-  taosMemoryFreeClear(pSub->unassignedVg);
-  taosMemoryFreeClear(pSub);
-  return NULL;
-}
-
-static FORCE_INLINE int32_t tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub) {
-  int32_t tlen = 0;
-  tlen += taosEncodeString(buf, pSub->key);
-  tlen += taosEncodeFixedI32(buf, pSub->vgNum);
-  tlen += taosEncodeFixedI32(buf, pSub->status);
-  int32_t sz;
-
-  sz = taosArrayGetSize(pSub->consumers);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqSubConsumer* pSubConsumer = taosArrayGet(pSub->consumers, i);
-    tlen += tEncodeSMqSubConsumer(buf, pSubConsumer);
-  }
-
-  sz = taosArrayGetSize(pSub->lostConsumers);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqSubConsumer* pSubConsumer = taosArrayGet(pSub->lostConsumers, i);
-    tlen += tEncodeSMqSubConsumer(buf, pSubConsumer);
-  }
-
-  sz = taosArrayGetSize(pSub->unassignedVg);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqConsumerEp* pCEp = taosArrayGet(pSub->unassignedVg, i);
-    tlen += tEncodeSMqConsumerEp(buf, pCEp);
-  }
-
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSubscribeObj(void* buf, SMqSubscribeObj* pSub) {
-  buf = taosDecodeStringTo(buf, pSub->key);
-  buf = taosDecodeFixedI32(buf, &pSub->vgNum);
-  buf = taosDecodeFixedI32(buf, &pSub->status);
-
-  int32_t sz;
-
-  buf = taosDecodeFixedI32(buf, &sz);
-  pSub->consumers = taosArrayInit(sz, sizeof(SMqSubConsumer));
-  if (pSub->consumers == NULL) {
-    return NULL;
-  }
-  for (int32_t i = 0; i < sz; i++) {
-    SMqSubConsumer subConsumer = {0};
-    buf = tDecodeSMqSubConsumer(buf, &subConsumer);
-    taosArrayPush(pSub->consumers, &subConsumer);
-  }
-
-  buf = taosDecodeFixedI32(buf, &sz);
-  pSub->lostConsumers = taosArrayInit(sz, sizeof(SMqSubConsumer));
-  if (pSub->lostConsumers == NULL) {
-    return NULL;
-  }
-  for (int32_t i = 0; i < sz; i++) {
-    SMqSubConsumer subConsumer = {0};
-    buf = tDecodeSMqSubConsumer(buf, &subConsumer);
-    taosArrayPush(pSub->lostConsumers, &subConsumer);
-  }
-
-  buf = taosDecodeFixedI32(buf, &sz);
-  pSub->unassignedVg = taosArrayInit(sz, sizeof(SMqConsumerEp));
-  if (pSub->unassignedVg == NULL) {
-    return NULL;
-  }
-  for (int32_t i = 0; i < sz; i++) {
-    SMqConsumerEp consumerEp = {0};
-    buf = tDecodeSMqConsumerEp(buf, &consumerEp);
-    taosArrayPush(pSub->unassignedVg, &consumerEp);
-  }
-  return buf;
-}
-
-static FORCE_INLINE void tDeleteSMqSubscribeObj(SMqSubscribeObj* pSub) {
-  if (pSub->consumers) {
-    // taosArrayDestroyEx(pSub->consumers, (void (*)(void*))tDeleteSMqSubConsumer);
-    //  taosArrayDestroy(pSub->consumers);
-    pSub->consumers = NULL;
-  }
-
-  if (pSub->unassignedVg) {
-    // taosArrayDestroyEx(pSub->unassignedVg, (void (*)(void*))tDeleteSMqConsumerEp);
-    //  taosArrayDestroy(pSub->unassignedVg);
-    pSub->unassignedVg = NULL;
-  }
-}
-#endif
-
-typedef struct {
-  char           name[TSDB_TOPIC_FNAME_LEN];
-  char           db[TSDB_DB_FNAME_LEN];
-  int64_t        createTime;
-  int64_t        updateTime;
-  int64_t        uid;
+  char    name[TSDB_TOPIC_FNAME_LEN];
+  char    db[TSDB_DB_FNAME_LEN];
+  int64_t createTime;
+  int64_t updateTime;
+  int64_t uid;
+  // TODO: use subDbUid
   int64_t        dbUid;
+  int64_t        subDbUid;
   int32_t        version;
+  int8_t         subType;  // db or table
+  int8_t         withTbName;
+  int8_t         withSchema;
+  int8_t         withTag;
+  int8_t         withTagSchema;
   SRWLatch       lock;
   int32_t        sqlLen;
   int32_t        astLen;
@@ -662,79 +459,6 @@ typedef struct {
   SSchemaWrapper schema;
 } SMqTopicObj;
 
-#if 0
-typedef struct {
-  int64_t  consumerId;
-  int64_t  connId;
-  SRWLatch lock;
-  char     cgroup[TSDB_CGROUP_LEN];
-  SArray*  currentTopics;        // SArray<char*>
-  SArray*  recentRemovedTopics;  // SArray<char*>
-  int32_t  epoch;
-  // stat
-  int64_t pollCnt;
-  // status
-  int32_t status;
-  // heartbeat from the consumer reset hbStatus to 0
-  // each checkConsumerAlive msg add hbStatus by 1
-  // if checkConsumerAlive > CONSUMER_REBALANCE_CNT, mask to lost
-  int32_t hbStatus;
-} SMqConsumerObj;
-
-static FORCE_INLINE int32_t tEncodeSMqConsumerObj(void** buf, const SMqConsumerObj* pConsumer) {
-  int32_t sz;
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pConsumer->consumerId);
-  tlen += taosEncodeFixedI64(buf, pConsumer->connId);
-  tlen += taosEncodeFixedI32(buf, pConsumer->epoch);
-  tlen += taosEncodeFixedI64(buf, pConsumer->pollCnt);
-  tlen += taosEncodeFixedI32(buf, pConsumer->status);
-  tlen += taosEncodeString(buf, pConsumer->cgroup);
-
-  sz = taosArrayGetSize(pConsumer->currentTopics);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    char* topic = taosArrayGetP(pConsumer->currentTopics, i);
-    tlen += taosEncodeString(buf, topic);
-  }
-
-  sz = taosArrayGetSize(pConsumer->recentRemovedTopics);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    char* topic = taosArrayGetP(pConsumer->recentRemovedTopics, i);
-    tlen += taosEncodeString(buf, topic);
-  }
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSMqConsumerObj(void* buf, SMqConsumerObj* pConsumer) {
-  int32_t sz;
-  buf = taosDecodeFixedI64(buf, &pConsumer->consumerId);
-  buf = taosDecodeFixedI64(buf, &pConsumer->connId);
-  buf = taosDecodeFixedI32(buf, &pConsumer->epoch);
-  buf = taosDecodeFixedI64(buf, &pConsumer->pollCnt);
-  buf = taosDecodeFixedI32(buf, &pConsumer->status);
-  buf = taosDecodeStringTo(buf, pConsumer->cgroup);
-
-  buf = taosDecodeFixedI32(buf, &sz);
-  pConsumer->currentTopics = taosArrayInit(sz, sizeof(void*));
-  for (int32_t i = 0; i < sz; i++) {
-    char* topic;
-    buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->currentTopics, &topic);
-  }
-
-  buf = taosDecodeFixedI32(buf, &sz);
-  pConsumer->recentRemovedTopics = taosArrayInit(sz, sizeof(void*));
-  for (int32_t i = 0; i < sz; i++) {
-    char* topic;
-    buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->recentRemovedTopics, &topic);
-  }
-  return buf;
-}
-#endif
-
 enum {
   CONSUMER_UPDATE__TOUCH = 1,
   CONSUMER_UPDATE__ADD,
@@ -753,12 +477,9 @@ typedef struct {
   int32_t hbStatus;
   // lock is used for topics update
   SRWLatch lock;
-  SArray*  currentTopics;  // SArray<char*>
-#if 0
-  SArray*  waitingRebTopics;  // SArray<char*>
-#endif
-  SArray* rebNewTopics;      // SArray<char*>
-  SArray* rebRemovedTopics;  // SArray<char*>
+  SArray*  currentTopics;     // SArray<char*>
+  SArray*  rebNewTopics;      // SArray<char*>
+  SArray*  rebRemovedTopics;  // SArray<char*>
 } SMqConsumerObj;
 
 SMqConsumerObj* tNewSMqConsumerObj(int64_t consumerId, char cgroup[TSDB_CGROUP_LEN]);
@@ -769,8 +490,7 @@ void*           tDecodeSMqConsumerObj(const void* buf, SMqConsumerObj* pConsumer
 typedef struct {
   int32_t vgId;
   char*   qmsg;
-  // char    topic[TSDB_TOPIC_FNAME_LEN];
-  SEpSet epSet;
+  SEpSet  epSet;
 } SMqVgEp;
 
 SMqVgEp* tCloneSMqVgEp(const SMqVgEp* pVgEp);
@@ -792,7 +512,14 @@ typedef struct {
   char      key[TSDB_SUBSCRIBE_KEY_LEN];
   SRWLatch  lock;
   int32_t   vgNum;
+  int8_t    subType;
+  int8_t    withTbName;
+  int8_t    withSchema;
+  int8_t    withTag;
+  int8_t    withTagSchema;
   SHashObj* consumerHash;  // consumerId -> SMqConsumerEpInSub
+  // TODO put -1 into unassignVgs
+  // SArray*   unassignedVgs;
 } SMqSubscribeObj;
 
 SMqSubscribeObj* tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]);
@@ -821,18 +548,6 @@ void                tDeleteSMqSubActionLogObj(SMqSubActionLogObj* pLog);
 int32_t             tEncodeSMqSubActionLogObj(void** buf, const SMqSubActionLogObj* pLog);
 void*               tDecodeSMqSubActionLogObj(const void* buf, SMqSubActionLogObj* pLog);
 
-typedef struct {
-  int64_t  consumerId;
-  char     cgroup[TSDB_CGROUP_LEN];
-  SRWLatch lock;
-  SArray*  vgs;  // SArray<SMqVgEp*>
-} SMqConsumerEpObj;
-
-SMqConsumerEpObj* tCloneSMqConsumerEpObj(const SMqConsumerEpObj* pConsumerEp);
-void              tDeleteSMqConsumerEpObj(SMqConsumerEpObj* pConsumerEp);
-int32_t           tEncodeSMqConsumerEpObj(void** buf, const SMqConsumerEpObj* pConsumerEp);
-void*             tDecodeSMqConsumerEpObj(const void* buf, SMqConsumerEpObj* pConsumerEp);
-
 typedef struct {
   const SMqSubscribeObj* pOldSub;
   const SMqTopicObj*     pTopic;
@@ -845,12 +560,6 @@ typedef struct {
   SMqVgEp* pVgEp;
 } SMqRebOutputVg;
 
-#if 0
-typedef struct {
-  int64_t consumerId;
-} SMqRebOutputConsumer;
-#endif
-
 typedef struct {
   SArray*               rebVgs;            // SArray<SMqRebOutputVg>
   SArray*               newConsumers;      // SArray<int64_t>
diff --git a/source/dnode/mnode/impl/inc/mndScheduler.h b/source/dnode/mnode/impl/inc/mndScheduler.h
index 42951beca2..33af040915 100644
--- a/source/dnode/mnode/impl/inc/mndScheduler.h
+++ b/source/dnode/mnode/impl/inc/mndScheduler.h
@@ -29,6 +29,8 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
 
 int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream);
 
+int32_t mndConvertRSmaTask(const char* ast, int8_t triggerType, int64_t watermark, char** pStr, int32_t* pLen);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index c67c6862e7..dab587432e 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -851,6 +851,8 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
   cfgRsp.cacheLastRow = pDb->cfg.cacheLastRow;
   cfgRsp.streamMode = pDb->cfg.streamMode;
   cfgRsp.singleSTable = pDb->cfg.singleSTable;
+  cfgRsp.numOfRetensions = pDb->cfg.numOfRetensions;
+  cfgRsp.pRetensions = pDb->cfg.pRetensions;
 
   int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);
   void   *pRsp = rpcMallocCont(contLen);
diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c
index 37c819ae60..78d54d273d 100644
--- a/source/dnode/mnode/impl/src/mndDef.c
+++ b/source/dnode/mnode/impl/src/mndDef.c
@@ -32,9 +32,6 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char cgroup[TSDB_CGROUP_L
   taosInitRWLatch(&pConsumer->lock);
 
   pConsumer->currentTopics = taosArrayInit(0, sizeof(void *));
-#if 0
-  pConsumer->waitingRebTopics = NULL;
-#endif
   pConsumer->rebNewTopics = taosArrayInit(0, sizeof(void *));
   pConsumer->rebRemovedTopics = taosArrayInit(0, sizeof(void *));
 
@@ -53,11 +50,6 @@ void tDeleteSMqConsumerObj(SMqConsumerObj *pConsumer) {
   if (pConsumer->currentTopics) {
     taosArrayDestroyP(pConsumer->currentTopics, (FDelete)taosMemoryFree);
   }
-#if 0
-  if (pConsumer->waitingRebTopics) {
-    taosArrayDestroyP(pConsumer->waitingRebTopics, taosMemoryFree);
-  }
-#endif
   if (pConsumer->rebNewTopics) {
     taosArrayDestroyP(pConsumer->rebNewTopics, (FDelete)taosMemoryFree);
   }
@@ -87,20 +79,6 @@ int32_t tEncodeSMqConsumerObj(void **buf, const SMqConsumerObj *pConsumer) {
     tlen += taosEncodeFixedI32(buf, 0);
   }
 
-#if 0
-  // waiting reb topics
-  if (pConsumer->waitingRebTopics) {
-    sz = taosArrayGetSize(pConsumer->waitingRebTopics);
-    tlen += taosEncodeFixedI32(buf, sz);
-    for (int32_t i = 0; i < sz; i++) {
-      char *topic = taosArrayGetP(pConsumer->waitingRebTopics, i);
-      tlen += taosEncodeString(buf, topic);
-    }
-  } else {
-    tlen += taosEncodeFixedI32(buf, 0);
-  }
-#endif
-
   // reb new topics
   if (pConsumer->rebNewTopics) {
     sz = taosArrayGetSize(pConsumer->rebNewTopics);
@@ -145,17 +123,6 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer) {
     taosArrayPush(pConsumer->currentTopics, &topic);
   }
 
-#if 0
-  // waiting reb topics
-  buf = taosDecodeFixedI32(buf, &sz);
-  pConsumer->waitingRebTopics = taosArrayInit(sz, sizeof(void *));
-  for (int32_t i = 0; i < sz; i++) {
-    char *topic;
-    buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->waitingRebTopics, &topic);
-  }
-#endif
-
   // reb new topics
   buf = taosDecodeFixedI32(buf, &sz);
   pConsumer->rebNewTopics = taosArrayInit(sz, sizeof(void *));
@@ -182,7 +149,6 @@ SMqVgEp *tCloneSMqVgEp(const SMqVgEp *pVgEp) {
   if (pVgEpNew == NULL) return NULL;
   pVgEpNew->vgId = pVgEp->vgId;
   pVgEpNew->qmsg = strdup(pVgEp->qmsg);
-  /*memcpy(pVgEpNew->topic, pVgEp->topic, TSDB_TOPIC_FNAME_LEN);*/
   pVgEpNew->epSet = pVgEp->epSet;
   return pVgEpNew;
 }
@@ -193,7 +159,6 @@ int32_t tEncodeSMqVgEp(void **buf, const SMqVgEp *pVgEp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pVgEp->vgId);
   tlen += taosEncodeString(buf, pVgEp->qmsg);
-  /*tlen += taosEncodeString(buf, pVgEp->topic);*/
   tlen += taosEncodeSEpSet(buf, &pVgEp->epSet);
   return tlen;
 }
@@ -201,40 +166,10 @@ int32_t tEncodeSMqVgEp(void **buf, const SMqVgEp *pVgEp) {
 void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp) {
   buf = taosDecodeFixedI32(buf, &pVgEp->vgId);
   buf = taosDecodeString(buf, &pVgEp->qmsg);
-  /*buf = taosDecodeStringTo(buf, pVgEp->topic);*/
   buf = taosDecodeSEpSet(buf, &pVgEp->epSet);
   return (void *)buf;
 }
 
-SMqConsumerEpObj *tCloneSMqConsumerEpObj(const SMqConsumerEpObj *pConsumerEp) {
-  SMqConsumerEpObj *pConsumerEpNew = taosMemoryMalloc(sizeof(SMqConsumerEpObj));
-  if (pConsumerEpNew == NULL) return NULL;
-  pConsumerEpNew->consumerId = pConsumerEp->consumerId;
-  memcpy(pConsumerEpNew->cgroup, pConsumerEp->cgroup, TSDB_CGROUP_LEN);
-  taosInitRWLatch(&pConsumerEpNew->lock);
-  pConsumerEpNew->vgs = taosArrayDeepCopy(pConsumerEpNew->vgs, (FCopy)tCloneSMqVgEp);
-  return pConsumerEpNew;
-}
-
-void tDeleteSMqConsumerEpObj(SMqConsumerEpObj *pConsumerEp) {
-  taosArrayDestroyEx(pConsumerEp->vgs, (FDelete)tDeleteSMqVgEp);
-}
-
-int32_t tEncodeSMqConsumerEpObj(void **buf, const SMqConsumerEpObj *pConsumerEp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
-  tlen += taosEncodeString(buf, pConsumerEp->cgroup);
-  tlen += taosEncodeArray(buf, pConsumerEp->vgs, (FEncode)tEncodeSMqVgEp);
-  return tlen;
-}
-
-void *tDecodeSMqConsumerEpObj(const void *buf, SMqConsumerEpObj *pConsumerEp) {
-  buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
-  buf = taosDecodeStringTo(buf, pConsumerEp->cgroup);
-  buf = taosDecodeArray(buf, &pConsumerEp->vgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqSubVgEp));
-  return (void *)buf;
-}
-
 SMqConsumerEpInSub *tCloneSMqConsumerEpInSub(const SMqConsumerEpInSub *pEpInSub) {
   SMqConsumerEpInSub *pEpInSubNew = taosMemoryMalloc(sizeof(SMqConsumerEpInSub));
   if (pEpInSubNew == NULL) return NULL;
@@ -276,7 +211,7 @@ void *tDecodeSMqConsumerEpInSub(const void *buf, SMqConsumerEpInSub *pEpInSub) {
 }
 
 SMqSubscribeObj *tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]) {
-  SMqSubscribeObj *pSubNew = taosMemoryMalloc(sizeof(SMqSubscribeObj));
+  SMqSubscribeObj *pSubNew = taosMemoryCalloc(1, sizeof(SMqSubscribeObj));
   if (pSubNew == NULL) return NULL;
   memcpy(pSubNew->key, key, TSDB_SUBSCRIBE_KEY_LEN);
   taosInitRWLatch(&pSubNew->lock);
@@ -297,8 +232,14 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
   if (pSubNew == NULL) return NULL;
   memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
   taosInitRWLatch(&pSubNew->lock);
+
+  pSubNew->subType = pSub->subType;
+  pSubNew->withTbName = pSub->withTbName;
+  pSubNew->withSchema = pSub->withSchema;
+  pSubNew->withTag = pSub->withTag;
+  pSubNew->withTagSchema = pSub->withTagSchema;
+
   pSubNew->vgNum = pSub->vgNum;
-  /*pSubNew->consumerEps = taosArrayDeepCopy(pSub->consumerEps, (FCopy)tCloneSMqConsumerEpInSub);*/
   pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
   /*taosHashSetFreeFp(pSubNew->consumerHash, taosArrayDestroy);*/
   void               *pIter = NULL;
@@ -325,6 +266,11 @@ int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) {
   int32_t tlen = 0;
   tlen += taosEncodeString(buf, pSub->key);
   tlen += taosEncodeFixedI32(buf, pSub->vgNum);
+  tlen += taosEncodeFixedI8(buf, pSub->subType);
+  tlen += taosEncodeFixedI8(buf, pSub->withTbName);
+  tlen += taosEncodeFixedI8(buf, pSub->withSchema);
+  tlen += taosEncodeFixedI8(buf, pSub->withTag);
+  tlen += taosEncodeFixedI8(buf, pSub->withTagSchema);
 
   void   *pIter = NULL;
   int32_t sz = taosHashGetSize(pSub->consumerHash);
@@ -347,6 +293,11 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub) {
   //
   buf = taosDecodeStringTo(buf, pSub->key);
   buf = taosDecodeFixedI32(buf, &pSub->vgNum);
+  buf = taosDecodeFixedI8(buf, &pSub->subType);
+  buf = taosDecodeFixedI8(buf, &pSub->withTbName);
+  buf = taosDecodeFixedI8(buf, &pSub->withSchema);
+  buf = taosDecodeFixedI8(buf, &pSub->withTag);
+  buf = taosDecodeFixedI8(buf, &pSub->withTagSchema);
 
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
diff --git a/source/dnode/mnode/impl/src/mndOffset.c b/source/dnode/mnode/impl/src/mndOffset.c
index dad912b4e6..f5433e8f9e 100644
--- a/source/dnode/mnode/impl/src/mndOffset.c
+++ b/source/dnode/mnode/impl/src/mndOffset.c
@@ -133,9 +133,9 @@ OFFSET_DECODE_OVER:
 int32_t mndCreateOffsets(STrans *pTrans, const char *cgroup, const char *topicName, const SArray *vgs) {
   int32_t sz = taosArrayGetSize(vgs);
   for (int32_t i = 0; i < sz; i++) {
-    SMqConsumerEp *pConsumerEp = taosArrayGet(vgs, i);
-    SMqOffsetObj   offsetObj;
-    if (mndMakePartitionKey(offsetObj.key, cgroup, topicName, pConsumerEp->vgId) < 0) {
+    int32_t      vgId = *(int32_t *)taosArrayGet(vgs, i);
+    SMqOffsetObj offsetObj;
+    if (mndMakePartitionKey(offsetObj.key, cgroup, topicName, vgId) < 0) {
       return -1;
     }
     offsetObj.offset = -1;
diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c
index 826a73afc6..ec4be8cba3 100644
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@@ -24,20 +24,20 @@
 #include "version.h"
 
 typedef struct {
-  uint32_t    id;
-  int8_t      connType;
-  char        user[TSDB_USER_LEN];
-  char        app[TSDB_APP_NAME_LEN];  // app name that invokes taosc
-  int64_t     appStartTimeMs;          // app start time
-  int32_t     pid;                     // pid of app that invokes taosc
-  uint32_t    ip;
-  uint16_t    port;
-  int8_t      killed;
-  int64_t     loginTimeMs;
-  int64_t     lastAccessTimeMs;
-  uint64_t    killId;
-  int32_t     numOfQueries;
-  SArray     *pQueries;      //SArray<SQueryDesc>
+  uint32_t id;
+  int8_t   connType;
+  char     user[TSDB_USER_LEN];
+  char     app[TSDB_APP_NAME_LEN];  // app name that invokes taosc
+  int64_t  appStartTimeMs;          // app start time
+  int32_t  pid;                     // pid of app that invokes taosc
+  uint32_t ip;
+  uint16_t port;
+  int8_t   killed;
+  int64_t  loginTimeMs;
+  int64_t  lastAccessTimeMs;
+  uint64_t killId;
+  int32_t  numOfQueries;
+  SArray * pQueries;  // SArray<SQueryDesc>
 } SConnObj;
 
 static SConnObj *mndCreateConn(SMnode *pMnode, const char *user, int8_t connType, uint32_t ip, uint16_t port,
@@ -45,7 +45,7 @@ static SConnObj *mndCreateConn(SMnode *pMnode, const char *user, int8_t connType
 static void      mndFreeConn(SConnObj *pConn);
 static SConnObj *mndAcquireConn(SMnode *pMnode, uint32_t connId);
 static void      mndReleaseConn(SMnode *pMnode, SConnObj *pConn);
-static void     *mndGetNextConn(SMnode *pMnode, SCacheIter *pIter);
+static void *    mndGetNextConn(SMnode *pMnode, SCacheIter *pIter);
 static void      mndCancelGetNextConn(SMnode *pMnode, void *pIter);
 static int32_t   mndProcessHeartBeatReq(SNodeMsg *pReq);
 static int32_t   mndProcessConnectReq(SNodeMsg *pReq);
@@ -71,9 +71,9 @@ int32_t mndInitProfile(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_KILL_QUERY, mndProcessKillQueryReq);
   mndSetMsgHandle(pMnode, TDMT_MND_KILL_CONN, mndProcessKillConnReq);
 
-//  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndRetrieveConns);
+  //  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndRetrieveConns);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndCancelGetNextConn);
-//  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndRetrieveQueries);
+  //  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndRetrieveQueries);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndCancelGetNextQuery);
 
   return 0;
@@ -91,7 +91,7 @@ static SConnObj *mndCreateConn(SMnode *pMnode, const char *user, int8_t connType
                                int32_t pid, const char *app, int64_t startTime) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
-  char connStr[255] = {0};
+  char    connStr[255] = {0};
   int32_t len = snprintf(connStr, sizeof(connStr), "%s%d%d%d%s", user, ip, port, pid, app);
   int32_t connId = mndGenerateUid(connStr, len);
   if (startTime == 0) startTime = taosGetTimestampMs();
@@ -174,10 +174,10 @@ static void mndCancelGetNextConn(SMnode *pMnode, void *pIter) {
 }
 
 static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
-  SMnode     *pMnode = pReq->pNode;
-  SUserObj   *pUser = NULL;
-  SDbObj     *pDb = NULL;
-  SConnObj   *pConn = NULL;
+  SMnode *    pMnode = pReq->pNode;
+  SUserObj *  pUser = NULL;
+  SDbObj *    pDb = NULL;
+  SConnObj *  pConn = NULL;
   int32_t     code = -1;
   SConnectReq connReq = {0};
   char        ip[30] = {0};
@@ -194,6 +194,11 @@ static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
     mError("user:%s, failed to login while acquire user since %s", pReq->user, terrstr());
     goto CONN_OVER;
   }
+  if (0 != strncmp(connReq.passwd, pUser->pass, TSDB_PASSWORD_LEN - 1)) {
+    mError("user:%s, failed to auth while acquire user\n %s \r\n %s", pReq->user, connReq.passwd, pUser->pass);
+    code = TSDB_CODE_RPC_AUTH_FAILURE;
+    goto CONN_OVER;
+  }
 
   if (connReq.db[0]) {
     char db[TSDB_DB_FNAME_LEN];
@@ -253,8 +258,8 @@ static int32_t mndSaveQueryList(SConnObj *pConn, SQueryHbReqBasic *pBasic) {
 
   pConn->pQueries = pBasic->queryDesc;
   pBasic->queryDesc = NULL;
-  
-  pConn->numOfQueries =  pBasic->queryDesc ? taosArrayGetSize(pBasic->queryDesc) : 0;
+
+  pConn->numOfQueries = pBasic->queryDesc ? taosArrayGetSize(pBasic->queryDesc) : 0;
 
   return TSDB_CODE_SUCCESS;
 }
@@ -324,9 +329,10 @@ static SClientHbRsp *mndMqHbBuildRsp(SMnode *pMnode, SClientHbReq *pReq) {
   return NULL;
 }
 
-static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHbReq *pHbReq, SClientHbBatchRsp *pBatchRsp) {
+static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHbReq *pHbReq,
+                                        SClientHbBatchRsp *pBatchRsp) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
-  SClientHbRsp hbRsp = {.connKey = pHbReq->connKey, .status = 0, .info = NULL, .query = NULL};
+  SClientHbRsp  hbRsp = {.connKey = pHbReq->connKey, .status = 0, .info = NULL, .query = NULL};
 
   if (pHbReq->query) {
     SQueryHbReqBasic *pBasic = pHbReq->query;
@@ -335,8 +341,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
     rpcGetConnInfo(pMsg->handle, &connInfo);
 
     SConnObj *pConn = mndAcquireConn(pMnode, pBasic->connId);
-    if (pConn == NULL) {    
-      pConn = mndCreateConn(pMnode, connInfo.user, CONN_TYPE__QUERY, connInfo.clientIp, connInfo.clientPort, pBasic->pid, pBasic->app, 0);
+    if (pConn == NULL) {
+      pConn = mndCreateConn(pMnode, connInfo.user, CONN_TYPE__QUERY, connInfo.clientIp, connInfo.clientPort,
+                            pBasic->pid, pBasic->app, 0);
       if (pConn == NULL) {
         mError("user:%s, conn:%u is freed and failed to create new since %s", connInfo.user, pBasic->connId, terrstr());
         return -1;
@@ -345,7 +352,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
       }
     } else if (pConn->killed) {
       mError("user:%s, conn:%u is already killed", connInfo.user, pConn->id);
-      mndReleaseConn(pMnode, pConn);      
+      mndReleaseConn(pMnode, pConn);
       terrno = TSDB_CODE_MND_INVALID_CONNECTION;
       return -1;
     }
@@ -369,8 +376,8 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
     }
 
     rspBasic->connId = pConn->id;
-    rspBasic->totalDnodes = 1;  //TODO
-    rspBasic->onlineDnodes = 1; //TODO
+    rspBasic->totalDnodes = 1;   // TODO
+    rspBasic->onlineDnodes = 1;  // TODO
     mndGetMnodeEpSet(pMnode, &rspBasic->epSet);
     mndReleaseConn(pMnode, pConn);
 
@@ -379,7 +386,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
 
   int32_t kvNum = taosHashGetSize(pHbReq->info);
   if (NULL == pHbReq->info || kvNum <= 0) {
-    taosArrayPush(pBatchRsp->rsps, &hbRsp);  
+    taosArrayPush(pBatchRsp->rsps, &hbRsp);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -396,7 +403,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
 
     switch (kv->key) {
       case HEARTBEAT_KEY_DBINFO: {
-        void   *rspMsg = NULL;
+        void *  rspMsg = NULL;
         int32_t rspLen = 0;
         mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbVgVersion), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
@@ -406,7 +413,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
         break;
       }
       case HEARTBEAT_KEY_STBINFO: {
-        void   *rspMsg = NULL;
+        void *  rspMsg = NULL;
         int32_t rspLen = 0;
         mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableMetaVersion), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
@@ -457,7 +464,7 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
   taosArrayDestroyEx(batchReq.reqs, tFreeClientHbReq);
 
   int32_t tlen = tSerializeSClientHbBatchRsp(NULL, 0, &batchRsp);
-  void   *buf = rpcMallocCont(tlen);
+  void *  buf = rpcMallocCont(tlen);
   tSerializeSClientHbBatchRsp(buf, tlen, &batchRsp);
 
   int32_t rspNum = (int32_t)taosArrayGetSize(batchRsp.rsps);
@@ -479,7 +486,7 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
 }
 
 static int32_t mndProcessKillQueryReq(SNodeMsg *pReq) {
-  SMnode       *pMnode = pReq->pNode;
+  SMnode *      pMnode = pReq->pNode;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
   SUserObj *pUser = mndAcquireUser(pMnode, pReq->user);
@@ -513,7 +520,7 @@ static int32_t mndProcessKillQueryReq(SNodeMsg *pReq) {
 }
 
 static int32_t mndProcessKillConnReq(SNodeMsg *pReq) {
-  SMnode       *pMnode = pReq->pNode;
+  SMnode *      pMnode = pReq->pNode;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
   SUserObj *pUser = mndAcquireUser(pMnode, pReq->user);
@@ -545,11 +552,11 @@ static int32_t mndProcessKillConnReq(SNodeMsg *pReq) {
 }
 
 static int32_t mndRetrieveConns(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode *  pMnode = pReq->pNode;
   int32_t   numOfRows = 0;
   SConnObj *pConn = NULL;
   int32_t   cols = 0;
-  char     *pWrite;
+  char *    pWrite;
   char      ipStr[TSDB_IPv4ADDR_LEN + 6];
 
   if (pShow->pIter == NULL) {
@@ -604,8 +611,8 @@ static int32_t mndRetrieveConns(SNodeMsg *pReq, SShowObj *pShow, char *data, int
 }
 
 static int32_t mndRetrieveQueries(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pReq->pNode;
-  int32_t   numOfRows = 0;
+  SMnode *pMnode = pReq->pNode;
+  int32_t numOfRows = 0;
 #if 0
   SConnObj *pConn = NULL;
   int32_t   cols = 0;
@@ -703,7 +710,7 @@ static int32_t mndRetrieveQueries(SNodeMsg *pReq, SShowObj *pShow, char *data, i
   }
 
   pShow->numOfRows += numOfRows;
-#endif  
+#endif
   return numOfRows;
 }
 
diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c
index b3583af1dc..73583058f1 100644
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@@ -34,6 +34,54 @@
 
 extern bool tsStreamSchedV;
 
+int32_t mndConvertRSmaTask(const char* ast, int8_t triggerType, int64_t watermark, char** pStr, int32_t* pLen) {
+  SNode*      pAst = NULL;
+  SQueryPlan* pPlan = NULL;
+  terrno = TSDB_CODE_SUCCESS;
+
+  if (nodesStringToNode(ast, &pAst) < 0) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    goto END;
+  }
+
+  SPlanContext cxt = {
+      .pAstRoot = pAst,
+      .topicQuery = false,
+      .streamQuery = true,
+      .rSmaQuery = true,
+      .triggerType = triggerType,
+      .watermark = watermark,
+  };
+  if (qCreateQueryPlan(&cxt, &pPlan, NULL) < 0) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    goto END;
+  }
+
+  int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
+  if (levelNum != 1) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    goto END;
+  }
+  SNodeListNode* inner = nodesListGetNode(pPlan->pSubplans, 0);
+
+  int32_t opNum = LIST_LENGTH(inner->pNodeList);
+  if (opNum != 1) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    goto END;
+  }
+
+  SSubplan* plan = nodesListGetNode(inner->pNodeList, 0);
+  if (qSubPlanToString(plan, pStr, pLen) < 0) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    goto END;
+  }
+
+END:
+  if (pAst) nodesDestroyNode(pAst);
+  if (pPlan) nodesDestroyNode(pPlan);
+  return terrno;
+}
+
 int32_t mndPersistTaskDeployReq(STrans* pTrans, SStreamTask* pTask, const SEpSet* pEpSet, tmsg_t type, int32_t nodeId) {
   SCoder encoder;
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, NULL, 0, TD_ENCODER);
diff --git a/source/dnode/mnode/impl/src/mndShow.c b/source/dnode/mnode/impl/src/mndShow.c
index 1a14c94640..f81179201c 100644
--- a/source/dnode/mnode/impl/src/mndShow.c
+++ b/source/dnode/mnode/impl/src/mndShow.c
@@ -18,7 +18,7 @@
 
 #define SHOW_STEP_SIZE 100
 
-static SShowObj *mndCreateShowObj(SMnode *pMnode, SShowReq *pReq);
+static SShowObj *mndCreateShowObj(SMnode *pMnode, SRetrieveTableReq *pReq);
 static void      mndFreeShowObj(SShowObj *pShow);
 static SShowObj *mndAcquireShowObj(SMnode *pMnode, int64_t showId);
 static void      mndReleaseShowObj(SShowObj *pShow, bool forceRemove);
@@ -47,18 +47,80 @@ void mndCleanupShow(SMnode *pMnode) {
   }
 }
 
-static SShowObj *mndCreateShowObj(SMnode *pMnode, SShowReq *pReq) {
+static int32_t convertToRetrieveType(char* name, int32_t len) {
+  int32_t type = -1;
+
+  if (strncasecmp(name, TSDB_INS_TABLE_DNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_DNODE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_MNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_MNODE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_MODULES, len) == 0) {
+    type = TSDB_MGMT_TABLE_MODULE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_QNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_QNODE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_BNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_BNODE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_SNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_SNODE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_CLUSTER, len) == 0) {
+    type = TSDB_MGMT_TABLE_CLUSTER;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_DATABASES, len) == 0) {
+    type = TSDB_MGMT_TABLE_DB;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_FUNCTIONS, len) == 0) {
+    type = TSDB_MGMT_TABLE_FUNC;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_INDEXES, len) == 0) {
+    //    type = TSDB_MGMT_TABLE_INDEX;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STABLES, len) == 0) {
+    type = TSDB_MGMT_TABLE_STB;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STREAMS, len) == 0) {
+    type = TSDB_MGMT_TABLE_STREAMS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLES, len) == 0) {
+    type = TSDB_MGMT_TABLE_TABLE;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED, len) == 0) {
+    //    type = TSDB_MGMT_TABLE_DIST;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_USERS, len) == 0) {
+    type = TSDB_MGMT_TABLE_USER;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_LICENCES, len) == 0) {
+    type = TSDB_MGMT_TABLE_GRANTS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_VGROUPS, len) == 0) {
+    type = TSDB_MGMT_TABLE_VGROUP;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_TOPICS, len) == 0) {
+    type = TSDB_MGMT_TABLE_TOPICS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_CONSUMERS, len) == 0) {
+    type = TSDB_MGMT_TABLE_CONSUMERS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_SUBSCRIBES, len) == 0) {
+    type = TSDB_MGMT_TABLE_SUBSCRIBES;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_TRANS, len) == 0) {
+    type = TSDB_MGMT_TABLE_TRANS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_SMAS, len) == 0) {
+    type = TSDB_MGMT_TABLE_SMAS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_CONFIGS, len) == 0) {
+    type = TSDB_MGMT_TABLE_CONFIGS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_CONNS, len) == 0) {
+    type = TSDB_MGMT_TABLE_CONNS;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_QUERIES, len) == 0) {
+    type = TSDB_MGMT_TABLE_QUERIES;
+  }  else if (strncasecmp(name, TSDB_INS_TABLE_VNODES, len) == 0) {
+    type = TSDB_MGMT_TABLE_VNODES;
+  } else {
+//    ASSERT(0);
+  }
+
+  return type;
+}
+
+static SShowObj *mndCreateShowObj(SMnode *pMnode, SRetrieveTableReq *pReq) {
   SShowMgmt *pMgmt = &pMnode->showMgmt;
 
   int64_t showId = atomic_add_fetch_64(&pMgmt->showId, 1);
   if (showId == 0) atomic_add_fetch_64(&pMgmt->showId, 1);
 
-  int32_t  size = sizeof(SShowObj) + pReq->payloadLen;
+  int32_t  size = sizeof(SShowObj);
+
   SShowObj showObj = {0};
-  showObj.id = showId;
+  showObj.id     = showId;
   showObj.pMnode = pMnode;
-  showObj.type = pReq->type;
-  showObj.payloadLen = pReq->payloadLen;
+  showObj.type   = convertToRetrieveType(pReq->tb, tListLen(pReq->tb));
   memcpy(showObj.db, pReq->db, TSDB_DB_FNAME_LEN);
 
   int32_t   keepTime = tsShellActivityTimer * 6 * 1000;
@@ -127,10 +189,6 @@ static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
   }
 
   if (retrieveReq.showId == 0) {
-    SShowReq req = {0};
-    req.type = retrieveReq.type;
-    strncpy(req.db, retrieveReq.db, tListLen(req.db));
-
     STableMetaRsp *pMeta = (STableMetaRsp *)taosHashGet(pMnode->infosMeta, retrieveReq.tb, strlen(retrieveReq.tb) + 1);
     if (pMeta == NULL) {
       terrno = TSDB_CODE_MND_INVALID_INFOS_TBL;
@@ -138,7 +196,7 @@ static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
       return -1;
     }
 
-    pShow = mndCreateShowObj(pMnode, &req);
+    pShow = mndCreateShowObj(pMnode, &retrieveReq);
     if (pShow == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       mError("failed to process show-meta req since %s", terrstr());
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 6bdf4575a8..f304e3153d 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -20,6 +20,7 @@
 #include "mndInfoSchema.h"
 #include "mndMnode.h"
 #include "mndPerfSchema.h"
+#include "mndScheduler.h"
 #include "mndShow.h"
 #include "mndTrans.h"
 #include "mndUser.h"
@@ -443,6 +444,25 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
     for (int32_t f = 0; f < pRSmaParam->nFuncIds; ++f) {
       *(pRSmaParam->pFuncIds + f) = pStb->aggregationMethod;
     }
+    if (pStb->ast1Len > 0) {
+      if (mndConvertRSmaTask(pStb->pAst1, 0, 0, &pRSmaParam->qmsg1, &pRSmaParam->qmsg1Len) != TSDB_CODE_SUCCESS) {
+        taosMemoryFreeClear(pRSmaParam->pFuncIds);
+        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
+        taosMemoryFreeClear(req.stbCfg.pSchema);
+        return NULL;
+      }
+    }
+    if (pStb->ast2Len > 0) {
+      int32_t qmsgLen2 = 0;
+      if (mndConvertRSmaTask(pStb->pAst2, 0, 0, &pRSmaParam->qmsg2, &pRSmaParam->qmsg2Len) != TSDB_CODE_SUCCESS) {
+        taosMemoryFreeClear(pRSmaParam->pFuncIds);
+        taosMemoryFreeClear(pRSmaParam->qmsg1);
+        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
+        taosMemoryFreeClear(req.stbCfg.pSchema);
+        return NULL;
+      }
+    }
+
     req.stbCfg.pRSmaParam = pRSmaParam;
   }
 
@@ -451,6 +471,8 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
   if (pHead == NULL) {
     if (pRSmaParam) {
       taosMemoryFreeClear(pRSmaParam->pFuncIds);
+      taosMemoryFreeClear(pRSmaParam->qmsg1);
+      taosMemoryFreeClear(pRSmaParam->qmsg2);
       taosMemoryFreeClear(pRSmaParam);
     }
     taosMemoryFreeClear(req.stbCfg.pSchema);
@@ -467,6 +489,8 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
   *pContLen = contLen;
   if (pRSmaParam) {
     taosMemoryFreeClear(pRSmaParam->pFuncIds);
+    taosMemoryFreeClear(pRSmaParam->qmsg1);
+    taosMemoryFreeClear(pRSmaParam->qmsg2);
     taosMemoryFreeClear(pRSmaParam);
   }
   taosMemoryFreeClear(req.stbCfg.pSchema);
diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c
index f708d4ffc1..e37bd60e12 100644
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@@ -46,16 +46,8 @@ static int32_t  mndSubActionInsert(SSdb *pSdb, SMqSubscribeObj *);
 static int32_t  mndSubActionDelete(SSdb *pSdb, SMqSubscribeObj *);
 static int32_t  mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubscribeObj *pNewSub);
 
-/*static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg);*/
-/*static int32_t mndProcessSubscribeRsp(SNodeMsg *pMsg);*/
-static int32_t mndProcessSubscribeInternalReq(SNodeMsg *pMsg);
-static int32_t mndProcessSubscribeInternalRsp(SNodeMsg *pMsg);
-/*static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg);*/
-/*static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg);*/
-/*static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg);*/
-/*static int32_t mndProcessResetOffsetReq(SNodeMsg *pMsg);*/
-
 static int32_t mndProcessRebalanceReq(SNodeMsg *pMsg);
+static int32_t mndProcessSubscribeInternalRsp(SNodeMsg *pMsg);
 
 static int32_t mndSetSubRedoLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) {
   SSdbRaw *pRedoRaw = mndSubActionEncode(pSub);
@@ -73,15 +65,6 @@ static int32_t mndSetSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeO
   return 0;
 }
 
-/*static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqTopicObj *pTopic, const char *cgroup,*/
-/*const SMqConsumerEp *pConsumerEp);*/
-
-/*static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,*/
-/*const char *topicName);*/
-
-/*static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,*/
-/*const char *oldTopicName);*/
-
 int32_t mndInitSubscribe(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_SUBSCRIBE,
                      .keyType = SDB_KEY_BINARY,
@@ -91,13 +74,6 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndSubActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndSubActionDelete};
 
-  /*mndSetMsgHandle(pMnode, TDMT_MND_SUBSCRIBE, mndProcessSubscribeReq);*/
-  /*mndSetMsgHandle(pMnode, TDMT_VND_MQ_SET_CONN_RSP, mndProcessSubscribeInternalRsp);*/
-  /*mndSetMsgHandle(pMnode, TDMT_VND_MQ_REB_RSP, mndProcessSubscribeInternalRsp);*/
-  /*mndSetMsgHandle(pMnode, TDMT_VND_MQ_CANCEL_CONN_RSP, mndProcessSubscribeInternalRsp);*/
-  /*mndSetMsgHandle(pMnode, TDMT_MND_MQ_TIMER, mndProcessMqTimerMsg);*/
-  /*mndSetMsgHandle(pMnode, TDMT_MND_GET_SUB_EP, mndProcessGetSubEpReq);*/
-  /*mndSetMsgHandle(pMnode, TDMT_MND_MQ_DO_REBALANCE, mndProcessDoRebalanceMsg);*/
   mndSetMsgHandle(pMnode, TDMT_VND_MQ_VG_CHANGE_RSP, mndProcessSubscribeInternalRsp);
   mndSetMsgHandle(pMnode, TDMT_MND_MQ_DO_REBALANCE, mndProcessRebalanceReq);
   return sdbSetTable(pMnode->pSdb, table);
@@ -109,6 +85,12 @@ static SMqSubscribeObj *mndCreateSub(SMnode *pMnode, const SMqTopicObj *pTopic,
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
+  pSub->subType = pTopic->subType;
+  pSub->withTbName = pTopic->withTbName;
+  pSub->withSchema = pTopic->withSchema;
+  pSub->withTag = pTopic->withTag;
+  pSub->withTagSchema = pTopic->withTagSchema;
+
   ASSERT(taosHashGetSize(pSub->consumerHash) == 1);
 
   if (mndSchedInitSubEp(pMnode, pTopic, pSub) < 0) {
@@ -122,144 +104,19 @@ static SMqSubscribeObj *mndCreateSub(SMnode *pMnode, const SMqTopicObj *pTopic,
   return pSub;
 }
 
-#if 0
-static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *cgroup) {
-  SMqSubscribeObj *pSub = tNewSubscribeObj();
-  if (pSub == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-  char key[TSDB_SUBSCRIBE_KEY_LEN];
-  mndMakeSubscribeKey(key, cgroup, pTopic->name);
-  strcpy(pSub->key, key);
-
-  if (mndSchedInitSubEp(pMnode, pTopic, pSub) < 0) {
-    tDeleteSMqSubscribeObj(pSub);
-    taosMemoryFree(pSub);
-    return NULL;
-  }
-
-  // TODO: disable alter subscribed table
-  return pSub;
-}
-
-static int32_t mndBuildRebalanceMsg(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp,
-                                    const char *topicName) {
-  SMqMVRebReq req = {
-      .vgId = pConsumerEp->vgId,
-      .oldConsumerId = pConsumerEp->oldConsumerId,
-      .newConsumerId = pConsumerEp->consumerId,
-  };
-  req.topic = strdup(topicName);
-
-  int32_t tlen = tEncodeSMqMVRebReq(NULL, &req);
-  void   *buf = taosMemoryMalloc(sizeof(SMsgHead) + tlen);
-  if (buf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-  SMsgHead *pMsgHead = (SMsgHead *)buf;
-
-  pMsgHead->contLen = htonl(sizeof(SMsgHead) + tlen);
-  pMsgHead->vgId = htonl(pConsumerEp->vgId);
-
-  void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
-  tEncodeSMqMVRebReq(&abuf, &req);
-  taosMemoryFree(req.topic);
-
-  *pBuf = buf;
-  *pLen = tlen;
-
-  return 0;
-}
-
-static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
-                                      const char *topicName) {
-  ASSERT(pConsumerEp->oldConsumerId != -1);
-
-  void   *buf;
-  int32_t tlen;
-  if (mndBuildRebalanceMsg(&buf, &tlen, pConsumerEp, topicName) < 0) {
-    return -1;
-  }
-
-  int32_t vgId = pConsumerEp->vgId;
-  SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId);
-
-  STransAction action = {0};
-  action.epSet = mndGetVgroupEpset(pMnode, pVgObj);
-  action.pCont = buf;
-  action.contLen = sizeof(SMsgHead) + tlen;
-  action.msgType = TDMT_VND_MQ_REB;
-
-  mndReleaseVgroup(pMnode, pVgObj);
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    taosMemoryFree(buf);
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t mndBuildCancelConnReq(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp,
-                                     const char *oldTopicName) {
-  SMqCancelConnReq req = {0};
-  req.consumerId = pConsumerEp->consumerId;
-  req.vgId = pConsumerEp->vgId;
-  req.epoch = pConsumerEp->epoch;
-  strcpy(req.topicName, oldTopicName);
-
-  int32_t tlen = tEncodeSMqCancelConnReq(NULL, &req);
-  void   *buf = taosMemoryMalloc(sizeof(SMsgHead) + tlen);
-  if (buf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-  SMsgHead *pMsgHead = (SMsgHead *)buf;
-
-  pMsgHead->contLen = htonl(sizeof(SMsgHead) + tlen);
-  pMsgHead->vgId = htonl(pConsumerEp->vgId);
-  void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
-  tEncodeSMqCancelConnReq(&abuf, &req);
-  *pBuf = buf;
-  *pLen = tlen;
-  return 0;
-}
-
-static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
-                                       const char *oldTopicName) {
-  void   *buf;
-  int32_t tlen;
-  if (mndBuildCancelConnReq(&buf, &tlen, pConsumerEp, oldTopicName) < 0) {
-    return -1;
-  }
-
-  int32_t vgId = pConsumerEp->vgId;
-  SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId);
-
-  STransAction action = {0};
-  action.epSet = mndGetVgroupEpset(pMnode, pVgObj);
-  action.pCont = buf;
-  action.contLen = sizeof(SMsgHead) + tlen;
-  action.msgType = TDMT_VND_MQ_CANCEL_CONN;
-
-  mndReleaseVgroup(pMnode, pVgObj);
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    taosMemoryFree(buf);
-    return -1;
-  }
-
-  return 0;
-}
-#endif
-
-static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const char *subKey, const SMqRebOutputVg *pRebVg) {
+static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscribeObj *pSub,
+                                    const SMqRebOutputVg *pRebVg) {
   SMqRebVgReq req = {0};
   req.oldConsumerId = pRebVg->oldConsumerId;
   req.newConsumerId = pRebVg->newConsumerId;
   req.vgId = pRebVg->pVgEp->vgId;
   req.qmsg = pRebVg->pVgEp->qmsg;
-  strncpy(req.subKey, subKey, TSDB_SUBSCRIBE_KEY_LEN);
+  req.subType = pSub->subType;
+  req.withTbName = pSub->withTbName;
+  req.withSchema = pSub->withSchema;
+  req.withTag = pSub->withTag;
+  req.withTagSchema = pSub->withTagSchema;
+  strncpy(req.subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
 
   int32_t tlen = sizeof(SMsgHead) + tEncodeSMqRebVgReq(NULL, &req);
   void   *buf = taosMemoryMalloc(tlen);
@@ -280,13 +137,13 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const char *subK
   return 0;
 }
 
-static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, const char *subKey,
+static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, const SMqSubscribeObj *pSub,
                                         const SMqRebOutputVg *pRebVg) {
   ASSERT(pRebVg->oldConsumerId != pRebVg->newConsumerId);
 
   void   *buf;
   int32_t tlen;
-  if (mndBuildSubChangeReq(&buf, &tlen, subKey, pRebVg) < 0) {
+  if (mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg) < 0) {
     return -1;
   }
 
@@ -307,108 +164,6 @@ static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, const ch
   return 0;
 }
 
-#if 0
-static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) {
-  SMnode           *pMnode = pMsg->pNode;
-  SMqCMGetSubEpReq *pReq = (SMqCMGetSubEpReq *)pMsg->rpcMsg.pCont;
-  SMqCMGetSubEpRsp  rsp = {0};
-  int64_t           consumerId = be64toh(pReq->consumerId);
-  int32_t           epoch = ntohl(pReq->epoch);
-
-  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMsg->pNode, consumerId);
-  if (pConsumer == NULL) {
-    terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
-    return -1;
-  }
-  // TODO add lock
-  ASSERT(strcmp(pReq->cgroup, pConsumer->cgroup) == 0);
-  int32_t serverEpoch = pConsumer->epoch;
-
-  // TODO
-  int32_t hbStatus = atomic_load_32(&pConsumer->hbStatus);
-  mDebug("consumer %ld epoch(%d) try to get sub ep, server epoch %d, old val: %d", consumerId, epoch, serverEpoch,
-         hbStatus);
-  atomic_store_32(&pConsumer->hbStatus, 0);
-  /*SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pConsumer);*/
-  /*sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);*/
-  /*sdbWrite(pMnode->pSdb, pConsumerRaw);*/
-
-  strcpy(rsp.cgroup, pReq->cgroup);
-  if (epoch != serverEpoch) {
-    mInfo("send new assignment to consumer %ld, consumer epoch %d, server epoch %d", pConsumer->consumerId, epoch,
-          serverEpoch);
-    mDebug("consumer %ld try r lock", consumerId);
-    taosRLockLatch(&pConsumer->lock);
-    mDebug("consumer %ld r locked", consumerId);
-    SArray *pTopics = pConsumer->currentTopics;
-    int32_t sz = taosArrayGetSize(pTopics);
-    rsp.topics = taosArrayInit(sz, sizeof(SMqSubTopicEp));
-    for (int32_t i = 0; i < sz; i++) {
-      char            *topicName = taosArrayGetP(pTopics, i);
-      SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topicName);
-      ASSERT(pSub);
-      int32_t csz = taosArrayGetSize(pSub->consumers);
-      // TODO: change to bsearch
-      for (int32_t j = 0; j < csz; j++) {
-        SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, j);
-        if (consumerId == pSubConsumer->consumerId) {
-          int32_t vgsz = taosArrayGetSize(pSubConsumer->vgInfo);
-          mInfo("topic %s has %d vg", topicName, serverEpoch);
-
-          SMqSubTopicEp topicEp;
-          strcpy(topicEp.topic, topicName);
-
-          SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topicName);
-          ASSERT(pTopic != NULL);
-          topicEp.schema = pTopic->schema;
-          mndReleaseTopic(pMnode, pTopic);
-
-          topicEp.vgs = taosArrayInit(vgsz, sizeof(SMqSubVgEp));
-          for (int32_t k = 0; k < vgsz; k++) {
-            char           offsetKey[TSDB_PARTITION_KEY_LEN];
-            SMqConsumerEp *pConsumerEp = taosArrayGet(pSubConsumer->vgInfo, k);
-            SMqSubVgEp     vgEp = {
-                    .epSet = pConsumerEp->epSet,
-                    .vgId = pConsumerEp->vgId,
-                    .offset = -1,
-            };
-            mndMakePartitionKey(offsetKey, pConsumer->cgroup, topicName, pConsumerEp->vgId);
-            SMqOffsetObj *pOffsetObj = mndAcquireOffset(pMnode, offsetKey);
-            if (pOffsetObj != NULL) {
-              vgEp.offset = pOffsetObj->offset;
-              mndReleaseOffset(pMnode, pOffsetObj);
-            }
-            taosArrayPush(topicEp.vgs, &vgEp);
-          }
-          taosArrayPush(rsp.topics, &topicEp);
-          break;
-        }
-      }
-      mndReleaseSubscribe(pMnode, pSub);
-    }
-    taosRUnLockLatch(&pConsumer->lock);
-    mDebug("consumer %ld r unlock", consumerId);
-  }
-  int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqCMGetSubEpRsp(NULL, &rsp);
-  void   *buf = rpcMallocCont(tlen);
-  if (buf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-  ((SMqRspHead *)buf)->mqMsgType = TMQ_MSG_TYPE__EP_RSP;
-  ((SMqRspHead *)buf)->epoch = serverEpoch;
-  ((SMqRspHead *)buf)->consumerId = pConsumer->consumerId;
-
-  void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
-  tEncodeSMqCMGetSubEpRsp(&abuf, &rsp);
-  tDeleteSMqCMGetSubEpRsp(&rsp);
-  mndReleaseConsumer(pMnode, pConsumer);
-  pMsg->pRsp = buf;
-  pMsg->rspLen = tlen;
-  return 0;
-}
-#endif
-
 static int32_t mndSplitSubscribeKey(const char *key, char *topic, char *cgroup) {
   int32_t i = 0;
   while (key[i] != TMQ_SEPARATOR) {
@@ -433,235 +188,6 @@ static SMqRebSubscribe *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) {
   return pRebSub;
 }
 
-#if 0
-static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg) {
-  SMnode            *pMnode = pMsg->pNode;
-  SSdb              *pSdb = pMnode->pSdb;
-  SMqConsumerObj    *pConsumer;
-  void              *pIter = NULL;
-  SMqDoRebalanceMsg *pRebMsg = rpcMallocCont(sizeof(SMqDoRebalanceMsg));
-  pRebMsg->rebSubHash = taosHashInit(64, MurmurHash3_32, true, HASH_NO_LOCK);
-
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer);
-    if (pIter == NULL) break;
-    int32_t hbStatus = atomic_add_fetch_32(&pConsumer->hbStatus, 1);
-    if (hbStatus > MND_SUBSCRIBE_REBALANCE_CNT) {
-      int32_t old =
-          atomic_val_compare_exchange_32(&pConsumer->status, MQ_CONSUMER_STATUS__ACTIVE, MQ_CONSUMER_STATUS__LOST);
-      if (old == MQ_CONSUMER_STATUS__ACTIVE) {
-        // get all topics of that topic
-        int32_t sz = taosArrayGetSize(pConsumer->currentTopics);
-        for (int32_t i = 0; i < sz; i++) {
-          char *topic = taosArrayGetP(pConsumer->currentTopics, i);
-          char  key[TSDB_SUBSCRIBE_KEY_LEN];
-          mndMakeSubscribeKey(key, pConsumer->cgroup, topic);
-          SMqRebSubscribe *pRebSub = mndGetOrCreateRebSub(pRebMsg->rebSubHash, key);
-          taosArrayPush(pRebSub->lostConsumers, &pConsumer->consumerId);
-        }
-      }
-    }
-    int32_t status = atomic_load_32(&pConsumer->status);
-    if (status == MQ_CONSUMER_STATUS__INIT || status == MQ_CONSUMER_STATUS__MODIFY) {
-      SArray *rebSubs;
-      if (status == MQ_CONSUMER_STATUS__INIT) {
-        rebSubs = pConsumer->currentTopics;
-      } else {
-        rebSubs = pConsumer->recentRemovedTopics;
-      }
-      int32_t sz = taosArrayGetSize(rebSubs);
-      for (int32_t i = 0; i < sz; i++) {
-        char *topic = taosArrayGetP(rebSubs, i);
-        char  key[TSDB_SUBSCRIBE_KEY_LEN];
-        mndMakeSubscribeKey(key, pConsumer->cgroup, topic);
-        SMqRebSubscribe *pRebSub = mndGetOrCreateRebSub(pRebMsg->rebSubHash, key);
-        if (status == MQ_CONSUMER_STATUS__INIT) {
-          taosArrayPush(pRebSub->newConsumers, &pConsumer->consumerId);
-        } else if (status == MQ_CONSUMER_STATUS__MODIFY) {
-          taosArrayPush(pRebSub->removedConsumers, &pConsumer->consumerId);
-        }
-      }
-      if (status == MQ_CONSUMER_STATUS__MODIFY) {
-        int32_t removeSz = taosArrayGetSize(pConsumer->recentRemovedTopics);
-        for (int32_t i = 0; i < removeSz; i++) {
-          char *topicName = taosArrayGetP(pConsumer->recentRemovedTopics, i);
-          taosMemoryFree(topicName);
-        }
-        taosArrayClear(pConsumer->recentRemovedTopics);
-      }
-    }
-  }
-  if (taosHashGetSize(pRebMsg->rebSubHash) != 0) {
-    mInfo("mq rebalance will be triggered");
-    SRpcMsg rpcMsg = {
-        .msgType = TDMT_MND_MQ_DO_REBALANCE,
-        .pCont = pRebMsg,
-        .contLen = sizeof(SMqDoRebalanceMsg),
-    };
-    tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
-  } else {
-    taosHashCleanup(pRebMsg->rebSubHash);
-    rpcFreeCont(pRebMsg);
-  }
-  return 0;
-}
-#endif
-
-#if 0
-static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) {
-  SMnode            *pMnode = pMsg->pNode;
-  SMqDoRebalanceMsg *pReq = pMsg->rpcMsg.pCont;
-  STrans            *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_REBALANCE, &pMsg->rpcMsg);
-  void              *pIter = NULL;
-
-  mInfo("mq rebalance start");
-
-  while (1) {
-    pIter = taosHashIterate(pReq->rebSubHash, pIter);
-    if (pIter == NULL) break;
-    SMqRebSubscribe *pRebSub = (SMqRebSubscribe *)pIter;
-    SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, pRebSub->key);
-
-    mInfo("mq rebalance subscription: %s, vgNum: %d, unassignedVg: %d", pSub->key, pSub->vgNum,
-          (int32_t)taosArrayGetSize(pSub->unassignedVg));
-
-    // remove lost consumer
-    for (int32_t i = 0; i < taosArrayGetSize(pRebSub->lostConsumers); i++) {
-      int64_t lostConsumerId = *(int64_t *)taosArrayGet(pRebSub->lostConsumers, i);
-
-      mInfo("mq remove lost consumer %" PRId64 "", lostConsumerId);
-
-      for (int32_t j = 0; j < taosArrayGetSize(pSub->consumers); j++) {
-        SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, j);
-        if (pSubConsumer->consumerId == lostConsumerId) {
-          taosArrayAddAll(pSub->unassignedVg, pSubConsumer->vgInfo);
-          taosArrayPush(pSub->lostConsumers, pSubConsumer);
-          taosArrayRemove(pSub->consumers, j);
-          break;
-        }
-      }
-    }
-
-    // calculate rebalance
-    int32_t consumerNum = taosArrayGetSize(pSub->consumers);
-    if (consumerNum != 0) {
-      int32_t vgNum = pSub->vgNum;
-      int32_t vgEachConsumer = vgNum / consumerNum;
-      int32_t imbalanceVg = vgNum % consumerNum;
-
-      // iterate all consumers, set unassignedVgStash
-      for (int32_t i = 0; i < consumerNum; i++) {
-        SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, i);
-        int32_t         vgThisConsumerBeforeRb = taosArrayGetSize(pSubConsumer->vgInfo);
-        int32_t         vgThisConsumerAfterRb;
-        if (i < imbalanceVg)
-          vgThisConsumerAfterRb = vgEachConsumer + 1;
-        else
-          vgThisConsumerAfterRb = vgEachConsumer;
-
-        mInfo("mq consumer:%" PRId64 ", connectted vgroup number change from %d to %d", pSubConsumer->consumerId,
-              vgThisConsumerBeforeRb, vgThisConsumerAfterRb);
-
-        while (taosArrayGetSize(pSubConsumer->vgInfo) > vgThisConsumerAfterRb) {
-          SMqConsumerEp *pConsumerEp = taosArrayPop(pSubConsumer->vgInfo);
-          ASSERT(pConsumerEp != NULL);
-          ASSERT(pConsumerEp->consumerId == pSubConsumer->consumerId);
-          taosArrayPush(pSub->unassignedVg, pConsumerEp);
-          mDebug("mq rebalance: vg %d push to unassignedVg", pConsumerEp->vgId);
-        }
-
-        SMqConsumerObj *pRebConsumer = mndAcquireConsumer(pMnode, pSubConsumer->consumerId);
-        mDebug("consumer %ld try w lock", pRebConsumer->consumerId);
-        taosWLockLatch(&pRebConsumer->lock);
-        mDebug("consumer %ld w locked", pRebConsumer->consumerId);
-        int32_t status = atomic_load_32(&pRebConsumer->status);
-        if (vgThisConsumerAfterRb != vgThisConsumerBeforeRb ||
-            (vgThisConsumerAfterRb != 0 && status != MQ_CONSUMER_STATUS__ACTIVE) ||
-            (vgThisConsumerAfterRb == 0 && status != MQ_CONSUMER_STATUS__LOST)) {
-          /*if (vgThisConsumerAfterRb != vgThisConsumerBeforeRb) {*/
-          /*pRebConsumer->epoch++;*/
-          /*}*/
-          if (vgThisConsumerAfterRb != 0) {
-            atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE);
-          } else {
-            atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__IDLE);
-          }
-
-          mInfo("mq consumer:%" PRId64 ", status change from %d to %d", pRebConsumer->consumerId, status,
-                pRebConsumer->status);
-
-          SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pRebConsumer);
-          sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);
-          mndTransAppendCommitlog(pTrans, pConsumerRaw);
-        }
-        taosWUnLockLatch(&pRebConsumer->lock);
-        mDebug("consumer %ld w unlock", pRebConsumer->consumerId);
-        mndReleaseConsumer(pMnode, pRebConsumer);
-      }
-
-      // assign to vgroup
-      if (taosArrayGetSize(pSub->unassignedVg) != 0) {
-        for (int32_t i = 0; i < consumerNum; i++) {
-          SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, i);
-          int32_t         vgThisConsumerAfterRb;
-          if (i < imbalanceVg)
-            vgThisConsumerAfterRb = vgEachConsumer + 1;
-          else
-            vgThisConsumerAfterRb = vgEachConsumer;
-
-          while (taosArrayGetSize(pSubConsumer->vgInfo) < vgThisConsumerAfterRb) {
-            SMqConsumerEp *pConsumerEp = taosArrayPop(pSub->unassignedVg);
-            mDebug("mq rebalance: vg %d pop from unassignedVg", pConsumerEp->vgId);
-            ASSERT(pConsumerEp != NULL);
-
-            pConsumerEp->oldConsumerId = pConsumerEp->consumerId;
-            pConsumerEp->consumerId = pSubConsumer->consumerId;
-            // TODO
-            pConsumerEp->epoch = 0;
-            taosArrayPush(pSubConsumer->vgInfo, pConsumerEp);
-
-            char topic[TSDB_TOPIC_FNAME_LEN];
-            char cgroup[TSDB_CGROUP_LEN];
-            mndSplitSubscribeKey(pSub->key, topic, cgroup);
-            if (pConsumerEp->oldConsumerId == -1) {
-              SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
-
-              mInfo("mq set conn: assign vgroup %d of topic %s to consumer %" PRId64 " cgroup: %s", pConsumerEp->vgId,
-                    topic, pConsumerEp->consumerId, cgroup);
-
-              mndPersistMqSetConnReq(pMnode, pTrans, pTopic, cgroup, pConsumerEp);
-              mndReleaseTopic(pMnode, pTopic);
-            } else {
-              mInfo("mq rebalance: assign vgroup %d, from consumer %" PRId64 " to consumer %" PRId64 "",
-                    pConsumerEp->vgId, pConsumerEp->oldConsumerId, pConsumerEp->consumerId);
-
-              mndPersistRebalanceMsg(pMnode, pTrans, pConsumerEp, topic);
-            }
-          }
-        }
-      }
-      ASSERT(taosArrayGetSize(pSub->unassignedVg) == 0);
-
-      // TODO: log rebalance statistics
-      SSdbRaw *pSubRaw = mndSubActionEncode(pSub);
-      sdbSetRawStatus(pSubRaw, SDB_STATUS_READY);
-      mndTransAppendRedolog(pTrans, pSubRaw);
-    }
-    mndReleaseSubscribe(pMnode, pSub);
-  }
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("mq-rebalance-trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    taosHashCleanup(pReq->rebSubHash);
-    mndTransDrop(pTrans);
-    return -1;
-  }
-
-  taosHashCleanup(pReq->rebSubHash);
-  mndTransDrop(pTrans);
-  return 0;
-}
-#endif
-
 static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
   if (pInput->pTopic != NULL) {
     // create subscribe
@@ -825,36 +351,6 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
       pRebVg->newConsumerId = pEpInSub->consumerId;
       taosArrayPush(pOutput->rebVgs, pRebVg);
     }
-
-#if 0
-    /*int32_t consumerVgNum = taosArrayGetSize(pEpInSub->vgs);*/
-    if (imbCnt < imbConsumerNum) {
-      imbCnt++;
-      // push until equal minVg + 1
-      while (taosArrayGetSize(pEpInSub->vgs) < minVgCnt + 1) {
-        // iter hash and find one vg
-        pRemovedIter = taosHashIterate(pHash, pRemovedIter);
-        ASSERT(pRemovedIter);
-        pRebVg = (SMqRebOutputVg *)pRemovedIter;
-        // push
-        taosArrayPush(pEpInSub->vgs, &pRebVg->pVgEp);
-        pRebVg->newConsumerId = pEpInSub->consumerId;
-        taosArrayPush(pOutput->rebVgs, pRebVg);
-      }
-    } else {
-      // push until equal minVg
-      while (taosArrayGetSize(pEpInSub->vgs) < minVgCnt) {
-        // iter hash and find one vg
-        pRemovedIter = taosHashIterate(pHash, pRemovedIter);
-        ASSERT(pRemovedIter);
-        pRebVg = (SMqRebOutputVg *)pRemovedIter;
-        // push
-        taosArrayPush(pEpInSub->vgs, &pRebVg->pVgEp);
-        pRebVg->newConsumerId = pEpInSub->consumerId;
-        taosArrayPush(pOutput->rebVgs, pRebVg);
-      }
-    }
-#endif
   }
 
   // 7. handle unassigned vg
@@ -911,7 +407,7 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SNodeMsg *pMsg, const SMqRebO
   int32_t       vgNum = taosArrayGetSize(rebVgs);
   for (int32_t i = 0; i < vgNum; i++) {
     SMqRebOutputVg *pRebVg = taosArrayGet(rebVgs, i);
-    if (mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub->key, pRebVg) < 0) {
+    if (mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg) < 0) {
       goto REB_FAIL;
     }
   }
@@ -1040,52 +536,6 @@ static int32_t mndProcessRebalanceReq(SNodeMsg *pMsg) {
   return 0;
 }
 
-static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqTopicObj *pTopic, const char *cgroup,
-                                      const SMqConsumerEp *pConsumerEp) {
-  ASSERT(pConsumerEp->oldConsumerId == -1);
-  int32_t vgId = pConsumerEp->vgId;
-
-  SMqSetCVgReq req = {
-      .vgId = vgId,
-      .consumerId = pConsumerEp->consumerId,
-      .sql = pTopic->sql,
-      .physicalPlan = pTopic->physicalPlan,
-      .qmsg = pConsumerEp->qmsg,
-  };
-
-  strcpy(req.cgroup, cgroup);
-  strcpy(req.topicName, pTopic->name);
-  int32_t tlen = tEncodeSMqSetCVgReq(NULL, &req);
-  void   *buf = taosMemoryMalloc(sizeof(SMsgHead) + tlen);
-  if (buf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  SMsgHead *pMsgHead = (SMsgHead *)buf;
-
-  pMsgHead->contLen = htonl(sizeof(SMsgHead) + tlen);
-  pMsgHead->vgId = htonl(vgId);
-
-  void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
-  tEncodeSMqSetCVgReq(&abuf, &req);
-
-  SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId);
-
-  STransAction action = {0};
-  action.epSet = mndGetVgroupEpset(pMnode, pVgObj);
-  action.pCont = buf;
-  action.contLen = sizeof(SMsgHead) + tlen;
-  action.msgType = TDMT_VND_MQ_SET_CONN;
-
-  mndReleaseVgroup(pMnode, pVgObj);
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    taosMemoryFree(buf);
-    return -1;
-  }
-  return 0;
-}
-
 void mndCleanupSubscribe(SMnode *pMnode) {}
 
 static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c
index b9c42fe899..22b1b404bb 100644
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@@ -76,7 +76,13 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
   SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime, TOPIC_ENCODE_OVER);
   SDB_SET_INT64(pRaw, dataPos, pTopic->uid, TOPIC_ENCODE_OVER);
   SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid, TOPIC_ENCODE_OVER);
+  SDB_SET_INT64(pRaw, dataPos, pTopic->subDbUid, TOPIC_ENCODE_OVER);
   SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER);
+  SDB_SET_INT8(pRaw, dataPos, pTopic->subType, TOPIC_ENCODE_OVER);
+  SDB_SET_INT8(pRaw, dataPos, pTopic->withTbName, TOPIC_ENCODE_OVER);
+  SDB_SET_INT8(pRaw, dataPos, pTopic->withSchema, TOPIC_ENCODE_OVER);
+  SDB_SET_INT8(pRaw, dataPos, pTopic->withTag, TOPIC_ENCODE_OVER);
+  SDB_SET_INT8(pRaw, dataPos, pTopic->withTagSchema, TOPIC_ENCODE_OVER);
   SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen, TOPIC_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_ENCODE_OVER);
   SDB_SET_INT32(pRaw, dataPos, pTopic->astLen, TOPIC_ENCODE_OVER);
@@ -134,7 +140,13 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT64(pRaw, dataPos, &pTopic->updateTime, TOPIC_DECODE_OVER);
   SDB_GET_INT64(pRaw, dataPos, &pTopic->uid, TOPIC_DECODE_OVER);
   SDB_GET_INT64(pRaw, dataPos, &pTopic->dbUid, TOPIC_DECODE_OVER);
+  SDB_GET_INT64(pRaw, dataPos, &pTopic->subDbUid, TOPIC_DECODE_OVER);
   SDB_GET_INT32(pRaw, dataPos, &pTopic->version, TOPIC_DECODE_OVER);
+  SDB_GET_INT8(pRaw, dataPos, &pTopic->subType, TOPIC_DECODE_OVER);
+  SDB_GET_INT8(pRaw, dataPos, &pTopic->withTbName, TOPIC_DECODE_OVER);
+  SDB_GET_INT8(pRaw, dataPos, &pTopic->withSchema, TOPIC_DECODE_OVER);
+  SDB_GET_INT8(pRaw, dataPos, &pTopic->withTag, TOPIC_DECODE_OVER);
+  SDB_GET_INT8(pRaw, dataPos, &pTopic->withTagSchema, TOPIC_DECODE_OVER);
 
   SDB_GET_INT32(pRaw, dataPos, &pTopic->sqlLen, TOPIC_DECODE_OVER);
   pTopic->sql = taosMemoryCalloc(pTopic->sqlLen, sizeof(char));
@@ -254,34 +266,14 @@ static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
     terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
     return -1;
   }
+
+  if ((pCreate->ast == NULL || pCreate->ast[0] == 0) && pCreate->subscribeDbName[0] == 0) {
+    terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+    return -1;
+  }
   return 0;
 }
 
-#if 0
-static int32_t mndGetPlanString(const SCMCreateTopicReq *pCreate, char **pStr) {
-  if (NULL == pCreate->ast) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SNode  *pAst = NULL;
-  int32_t code = nodesStringToNode(pCreate->ast, &pAst);
-
-  SQueryPlan *pPlan = NULL;
-  if (TSDB_CODE_SUCCESS == code) {
-    SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
-    code = qCreateQueryPlan(&cxt, &pPlan, NULL);
-  }
-
-  if (TSDB_CODE_SUCCESS == code) {
-    code = nodesNodeToString(pPlan, false, pStr, NULL);
-  }
-  nodesDestroyNode(pAst);
-  nodesDestroyNode(pPlan);
-  terrno = code;
-  return code;
-}
-#endif
-
 static int32_t mndCreateTopic(SMnode *pMnode, SNodeMsg *pReq, SCMCreateTopicReq *pCreate, SDbObj *pDb) {
   mDebug("topic:%s to create", pCreate->name);
   SMqTopicObj topicObj = {0};
@@ -297,28 +289,38 @@ static int32_t mndCreateTopic(SMnode *pMnode, SNodeMsg *pReq, SCMCreateTopicReq
   topicObj.ast = strdup(pCreate->ast);
   topicObj.astLen = strlen(pCreate->ast) + 1;
 
-  SNode *pAst = NULL;
-  if (nodesStringToNode(pCreate->ast, &pAst) != 0) {
-    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
-  }
+  if (pCreate->ast && pCreate->ast[0]) {
+    topicObj.subType = TOPIC_SUB_TYPE__TABLE;
+    topicObj.withTbName = 0;
+    topicObj.withSchema = 0;
 
-  SQueryPlan *pPlan = NULL;
+    SNode *pAst = NULL;
+    if (nodesStringToNode(pCreate->ast, &pAst) != 0) {
+      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
 
-  SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
-  if (qCreateQueryPlan(&cxt, &pPlan, NULL) != 0) {
-    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
-  }
+    SQueryPlan *pPlan = NULL;
 
-  if (qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema) != 0) {
-    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
-  }
+    SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
+    if (qCreateQueryPlan(&cxt, &pPlan, NULL) != 0) {
+      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
 
-  if (nodesNodeToString(pPlan, false, &topicObj.physicalPlan, NULL) != 0) {
-    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+    if (qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema) != 0) {
+      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
+
+    if (nodesNodeToString(pPlan, false, &topicObj.physicalPlan, NULL) != 0) {
+      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
+  } else {
+    topicObj.subType = TOPIC_SUB_TYPE__DB;
+    topicObj.withTbName = 1;
+    topicObj.withSchema = 1;
   }
 
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_TOPIC, &pReq->rpcMsg);
diff --git a/source/dnode/mnode/impl/test/profile/profile.cpp b/source/dnode/mnode/impl/test/profile/profile.cpp
index 2c3be2135b..9c8e0298aa 100644
--- a/source/dnode/mnode/impl/test/profile/profile.cpp
+++ b/source/dnode/mnode/impl/test/profile/profile.cpp
@@ -30,8 +30,15 @@ int32_t  MndTestProfile::connId;
 TEST_F(MndTestProfile, 01_ConnectMsg) {
   SConnectReq connectReq = {0};
   connectReq.pid = 1234;
+
+  char passwd[] = "taosdata";
+  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
+  taosEncryptPass_c((uint8_t*)passwd, strlen(passwd), secretEncrypt);
+
   strcpy(connectReq.app, "mnode_test_profile");
   strcpy(connectReq.db, "");
+  strcpy(connectReq.user, "root");
+  strcpy(connectReq.passwd, secretEncrypt);
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
   void*   pReq = rpcMallocCont(contLen);
@@ -58,10 +65,16 @@ TEST_F(MndTestProfile, 01_ConnectMsg) {
 }
 
 TEST_F(MndTestProfile, 02_ConnectMsg_InvalidDB) {
+  char passwd[] = "taosdata";
+  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
+  taosEncryptPass_c((uint8_t*)passwd, strlen(passwd), secretEncrypt);
+
   SConnectReq connectReq = {0};
   connectReq.pid = 1234;
   strcpy(connectReq.app, "mnode_test_profile");
   strcpy(connectReq.db, "invalid_db");
+  strcpy(connectReq.user, "root");
+  strcpy(connectReq.passwd, secretEncrypt);
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
   void*   pReq = rpcMallocCont(contLen);
diff --git a/source/dnode/mnode/impl/test/show/show.cpp b/source/dnode/mnode/impl/test/show/show.cpp
index 201a42e3ef..5c431f65d3 100644
--- a/source/dnode/mnode/impl/test/show/show.cpp
+++ b/source/dnode/mnode/impl/test/show/show.cpp
@@ -36,7 +36,7 @@ TEST_F(MndTestShow, 01_ShowMsg_InvalidMsgMax) {
 
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_SYSTABLE_RETRIEVE, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);
-  ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_MSG);
+  ASSERT_NE(pRsp->code, 0);
 }
 
 TEST_F(MndTestShow, 02_ShowMsg_InvalidMsgStart) {
@@ -50,14 +50,20 @@ TEST_F(MndTestShow, 02_ShowMsg_InvalidMsgStart) {
 
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_SYSTABLE_RETRIEVE, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);
-  ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_MSG);
+  ASSERT_NE(pRsp->code, 0);
 }
 
 TEST_F(MndTestShow, 03_ShowMsg_Conn) {
+  char passwd[] = "taosdata";
+  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
+  taosEncryptPass_c((uint8_t*)passwd, strlen(passwd), secretEncrypt);
+
   SConnectReq connectReq = {0};
   connectReq.pid = 1234;
   strcpy(connectReq.app, "mnode_test_show");
   strcpy(connectReq.db, "");
+  strcpy(connectReq.user, "root");
+  strcpy(connectReq.passwd, secretEncrypt);
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
   void*   pReq = rpcMallocCont(contLen);
@@ -74,4 +80,4 @@ TEST_F(MndTestShow, 03_ShowMsg_Conn) {
 TEST_F(MndTestShow, 04_ShowMsg_Cluster) {
   test.SendShowReq(TSDB_MGMT_TABLE_CLUSTER, "cluster", "");
   EXPECT_EQ(test.GetShowRows(), 1);
-}
\ No newline at end of file
+}
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 834d11fc20..2b52d333da 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -109,8 +109,7 @@ int     tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList
 int     tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
 bool    tqNextDataBlock(STqReadHandle *pHandle);
-int     tqRetrieveDataBlockInfo(STqReadHandle *pHandle, SDataBlockInfo *pBlockInfo);
-SArray *tqRetrieveDataBlock(STqReadHandle *pHandle);
+int32_t tqRetrieveDataBlock(SArray **ppCols, STqReadHandle *pHandle, uint64_t *pGroupId, int32_t *pNumOfRows);
 
 // need to reposition
 
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index ce9549af56..a84776abfd 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -391,6 +391,7 @@ struct SReadH {
 #define TSDB_READ_REPO_ID(rh)   REPO_ID(TSDB_READ_REPO(rh))
 #define TSDB_READ_FSET(rh)      (&((rh)->rSet))
 #define TSDB_READ_TABLE(rh)     ((rh)->pTable)
+#define TSDB_READ_TABLE_UID(rh) ((rh)->pTable->uid)
 #define TSDB_READ_HEAD_FILE(rh) TSDB_DFILE_IN_SET(TSDB_READ_FSET(rh), TSDB_FILE_HEAD)
 #define TSDB_READ_DATA_FILE(rh) TSDB_DFILE_IN_SET(TSDB_READ_FSET(rh), TSDB_FILE_DATA)
 #define TSDB_READ_LAST_FILE(rh) TSDB_DFILE_IN_SET(TSDB_READ_FSET(rh), TSDB_FILE_LAST)
diff --git a/source/dnode/vnode/src/meta/metaTDBImpl.c b/source/dnode/vnode/src/meta/metaTDBImpl.c
index 9fd11222bf..149a7ca3cb 100644
--- a/source/dnode/vnode/src/meta/metaTDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaTDBImpl.c
@@ -626,14 +626,8 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
 #ifdef META_TDB_SMA_TEST
   STSmaWrapper *pSW = NULL;
 
-  pSW = taosMemoryCalloc(1, sizeof(*pSW));
-  if (pSW == NULL) {
-    return NULL;
-  }
-
   SMSmaCursor *pCur = metaOpenSmaCursor(pMeta, uid);
   if (pCur == NULL) {
-    taosMemoryFree(pSW);
     return NULL;
   }
 
@@ -653,6 +647,12 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
         continue;
       }
 
+      if ((pSW == NULL) && ((pSW = taosMemoryCalloc(1, sizeof(*pSW))) == NULL)) {
+        TDB_FREE(pSmaVal);
+        metaCloseSmaCursor(pCur);
+        return NULL;
+      }
+
       ++pSW->number;
       STSma *tptr = (STSma *)taosMemoryRealloc(pSW->tSma, pSW->number * sizeof(STSma));
       if (tptr == NULL) {
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index c7c8054120..510dd32459 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -618,127 +618,6 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
   }
 }
 
-#if 0
-int32_t tqProcessRebReq(STQ* pTq, char* msg) {
-  SMqMVRebReq req = {0};
-  terrno = TSDB_CODE_SUCCESS;
-  tDecodeSMqMVRebReq(msg, &req);
-
-  vDebug("vg %d set from consumer %ld to consumer %ld", req.vgId, req.oldConsumerId, req.newConsumerId);
-  STqConsumer* pConsumer = tqHandleGet(pTq->tqMeta, req.oldConsumerId);
-  ASSERT(pConsumer);
-  ASSERT(pConsumer->consumerId == req.oldConsumerId);
-  int32_t numOfTopics = taosArrayGetSize(pConsumer->topics);
-  if (numOfTopics == 1) {
-    STqTopic* pTopic = taosArrayGet(pConsumer->topics, 0);
-    ASSERT(strcmp(pTopic->topicName, req.topic) == 0);
-    STqConsumer* pNewConsumer = tqHandleGet(pTq->tqMeta, req.newConsumerId);
-    if (pNewConsumer == NULL) {
-      pConsumer->consumerId = req.newConsumerId;
-      tqHandleMovePut(pTq->tqMeta, req.newConsumerId, pConsumer);
-      tqHandleCommit(pTq->tqMeta, req.newConsumerId);
-      tqHandlePurge(pTq->tqMeta, req.oldConsumerId);
-      return 0;
-    } else {
-      taosArrayPush(pNewConsumer->topics, pTopic);
-    }
-  } else {
-    for (int32_t i = 0; i < numOfTopics; i++) {
-      STqTopic* pTopic = taosArrayGet(pConsumer->topics, i);
-      if (strcmp(pTopic->topicName, req.topic) == 0) {
-        STqConsumer* pNewConsumer = tqHandleGet(pTq->tqMeta, req.newConsumerId);
-        if (pNewConsumer == NULL) {
-          pNewConsumer = taosMemoryCalloc(1, sizeof(STqConsumer));
-          if (pNewConsumer == NULL) {
-            terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
-            return -1;
-          }
-          strcpy(pNewConsumer->cgroup, pConsumer->cgroup);
-          pNewConsumer->topics = taosArrayInit(0, sizeof(STqTopic));
-          pNewConsumer->consumerId = req.newConsumerId;
-          pNewConsumer->epoch = 0;
-
-          taosArrayPush(pNewConsumer->topics, pTopic);
-          tqHandleMovePut(pTq->tqMeta, req.newConsumerId, pConsumer);
-          tqHandleCommit(pTq->tqMeta, req.newConsumerId);
-          return 0;
-        }
-        ASSERT(pNewConsumer->consumerId == req.newConsumerId);
-        taosArrayPush(pNewConsumer->topics, pTopic);
-        break;
-      }
-    }
-    //
-  }
-  return 0;
-}
-
-int32_t tqProcessSetConnReq(STQ* pTq, char* msg) {
-  SMqSetCVgReq req = {0};
-  tDecodeSMqSetCVgReq(msg, &req);
-  bool create = false;
-
-  vDebug("vg %d set to consumer %ld", req.vgId, req.consumerId);
-  STqConsumer* pConsumer = tqHandleGet(pTq->tqMeta, req.consumerId);
-  if (pConsumer == NULL) {
-    pConsumer = taosMemoryCalloc(1, sizeof(STqConsumer));
-    if (pConsumer == NULL) {
-      terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
-      return -1;
-    }
-    strcpy(pConsumer->cgroup, req.cgroup);
-    pConsumer->topics = taosArrayInit(0, sizeof(STqTopic));
-    pConsumer->consumerId = req.consumerId;
-    pConsumer->epoch = 0;
-    create = true;
-  }
-
-  STqTopic* pTopic = taosMemoryCalloc(1, sizeof(STqTopic));
-  if (pTopic == NULL) {
-    taosArrayDestroy(pConsumer->topics);
-    taosMemoryFree(pConsumer);
-    return -1;
-  }
-  strcpy(pTopic->topicName, req.topicName);
-  pTopic->sql = req.sql;
-  pTopic->physicalPlan = req.physicalPlan;
-  pTopic->qmsg = req.qmsg;
-  /*pTopic->committedOffset = -1;*/
-  /*pTopic->currentOffset = -1;*/
-
-  pTopic->buffer.firstOffset = -1;
-  pTopic->buffer.lastOffset = -1;
-  pTopic->pReadhandle = walOpenReadHandle(pTq->pWal);
-  if (pTopic->pReadhandle == NULL) {
-    ASSERT(false);
-  }
-  for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
-    pTopic->buffer.output[i].status = 0;
-    STqReadHandle* pReadHandle = tqInitSubmitMsgScanner(pTq->pVnodeMeta);
-    SReadHandle    handle = {
-           .reader = pReadHandle,
-           .meta = pTq->pVnodeMeta,
-    };
-    pTopic->buffer.output[i].pReadHandle = pReadHandle;
-    pTopic->buffer.output[i].task = qCreateStreamExecTaskInfo(req.qmsg, &handle);
-    ASSERT(pTopic->buffer.output[i].task);
-  }
-  vDebug("set topic %s to consumer %ld on vg %d", pTopic->topicName, req.consumerId, TD_VID(pTq->pVnode));
-  taosArrayPush(pConsumer->topics, pTopic);
-  if (create) {
-    tqHandleMovePut(pTq->tqMeta, req.consumerId, pConsumer);
-    tqHandleCommit(pTq->tqMeta, req.consumerId);
-  }
-  terrno = TSDB_CODE_SUCCESS;
-  return 0;
-}
-
-int32_t tqProcessCancelConnReq(STQ* pTq, char* msg) {
-  terrno = TSDB_CODE_SUCCESS;
-  return 0;
-}
-#endif
-
 int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask, int32_t parallel) {
   if (pTask->execType == TASK_EXEC__NONE) return 0;
 
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index cf62ea8714..02ce6c4aad 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -82,16 +82,7 @@ bool tqNextDataBlock(STqReadHandle* pHandle) {
   return false;
 }
 
-int tqRetrieveDataBlockInfo(STqReadHandle* pHandle, SDataBlockInfo* pBlockInfo) {
-  // currently only rows are used
-
-  pBlockInfo->numOfCols = taosArrayGetSize(pHandle->pColIdList);
-  pBlockInfo->rows = pHandle->pBlock->numOfRows;
-  //  pBlockInfo->uid = pHandle->pBlock->uid; // the uid can not be assigned to pBlockData.
-  return 0;
-}
-
-SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
+int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* pGroupId, int32_t* pNumOfRows) {
   /*int32_t         sversion = pHandle->pBlock->sversion;*/
   // TODO set to real sversion
   int32_t sversion = 0;
@@ -112,7 +103,7 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
   STSchema*       pTschema = pHandle->pSchema;
   SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
 
-  int32_t numOfRows = pHandle->pBlock->numOfRows;
+  *pNumOfRows = pHandle->pBlock->numOfRows;
   /*int32_t numOfCols = pHandle->pSchema->numOfCols;*/
   int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
 
@@ -120,10 +111,11 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
     colNumNeed = pSchemaWrapper->nCols;
   }
 
-  SArray* pArray = taosArrayInit(colNumNeed, sizeof(SColumnInfoData));
-  if (pArray == NULL) {
-    return NULL;
+  *ppCols = taosArrayInit(colNumNeed, sizeof(SColumnInfoData));
+  if (*ppCols == NULL) {
+    return -1;
   }
+
   int32_t colMeta = 0;
   int32_t colNeed = 0;
   while (colMeta < pSchemaWrapper->nCols && colNeed < colNumNeed) {
@@ -136,21 +128,24 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
       colNeed++;
     } else {
       SColumnInfoData colInfo = {0};
-      /*int             sz = numOfRows * pColSchema->bytes;*/
       colInfo.info.bytes = pColSchema->bytes;
       colInfo.info.colId = pColSchema->colId;
       colInfo.info.type = pColSchema->type;
 
-      if (colInfoDataEnsureCapacity(&colInfo, 0, numOfRows) < 0) {
-        taosArrayDestroyEx(pArray, (void (*)(void*))tDeleteSSDataBlock);
-        return NULL;
+      if (colInfoDataEnsureCapacity(&colInfo, 0, *pNumOfRows) < 0) {
+        goto FAIL;
       }
-      taosArrayPush(pArray, &colInfo);
+      taosArrayPush(*ppCols, &colInfo);
       colMeta++;
       colNeed++;
     }
   }
 
+  int32_t colActual = taosArrayGetSize(*ppCols);
+
+  // TODO in stream shuffle case, fetch groupId
+  *pGroupId = 0;
+
   STSRowIter iter = {0};
   tdSTSRowIterInit(&iter, pTschema);
   STSRow* row;
@@ -159,22 +154,22 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
   while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);
     // get all wanted col of that block
-    int32_t colTot = taosArrayGetSize(pArray);
-    for (int32_t i = 0; i < colTot; i++) {
-      SColumnInfoData* pColData = taosArrayGet(pArray, i);
+    for (int32_t i = 0; i < colActual; i++) {
+      SColumnInfoData* pColData = taosArrayGet(*ppCols, i);
       SCellVal         sVal = {0};
       if (!tdSTSRowIterNext(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
         break;
       }
-      /*if (colDataAppend(pColData, curRow, sVal.val, false) < 0) {*/
       if (colDataAppend(pColData, curRow, sVal.val, sVal.valType == TD_VTYPE_NULL) < 0) {
-        taosArrayDestroyEx(pArray, (void (*)(void*))tDeleteSSDataBlock);
-        return NULL;
+        goto FAIL;
       }
     }
     curRow++;
   }
-  return pArray;
+  return 0;
+FAIL:
+  taosArrayDestroy(*ppCols);
+  return -1;
 }
 
 void tqReadHandleSetColIdList(STqReadHandle* pReadHandle, SArray* pColIdList) { pReadHandle->pColIdList = pColIdList; }
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index fd640471bd..f70a4478b3 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -3260,6 +3260,9 @@ int32_t tsdbRetrieveDataBlockStatisInfo(tsdbReaderT* pTsdbReadHandle, SColumnDat
     return TSDB_CODE_SUCCESS;
   }
 
+  tsdbDebug("vgId:%d succeed to load block statis part for uid %" PRIu64, REPO_ID(pHandle->pTsdb),
+            TSDB_READ_TABLE_UID(&pHandle->rhelper));
+
   int16_t* colIds = pHandle->defaultLoadColumn->pData;
 
   size_t numOfCols = QH_GET_NUM_OF_COLS(pHandle);
diff --git a/source/dnode/vnode/src/tsdb/tsdbReadImpl.c b/source/dnode/vnode/src/tsdb/tsdbReadImpl.c
index 0cf8a0d359..f18f36e07b 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReadImpl.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReadImpl.c
@@ -322,15 +322,18 @@ int tsdbLoadBlockStatis(SReadH *pReadh, SBlock *pBlock) {
   ASSERT(pBlock->numOfSubBlocks <= 1);
 
   if (!pBlock->aggrStat) {
+    tsdbDebug("vgId:%d no need to load block statis part for uid %" PRIu64 " since not exist", REPO_ID(pReadh->pRepo),
+              TSDB_READ_TABLE_UID(pReadh));
     return TSDB_STATIS_NONE;
   }
 
   SDFile *pDFileAggr = pBlock->last ? TSDB_READ_SMAL_FILE(pReadh) : TSDB_READ_SMAD_FILE(pReadh);
 
   if (tsdbSeekDFile(pDFileAggr, pBlock->aggrOffset, SEEK_SET) < 0) {
-    tsdbError("vgId:%d failed to load block aggr part while seek file %s to offset %" PRIu64 " since %s",
-              TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr), (uint64_t)pBlock->aggrOffset,
-              tstrerror(terrno));
+    tsdbError("vgId:%d failed to load block statis part for uid %" PRIu64 " while seek file %s to offset %" PRIu64
+              " since %s",
+              TSDB_READ_REPO_ID(pReadh), TSDB_READ_TABLE_UID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr),
+              (uint64_t)pBlock->aggrOffset, tstrerror(terrno));
     return -1;
   }
 
@@ -339,25 +342,28 @@ int tsdbLoadBlockStatis(SReadH *pReadh, SBlock *pBlock) {
 
   int64_t nreadAggr = tsdbReadDFile(pDFileAggr, (void *)(pReadh->pAggrBlkData), sizeAggr);
   if (nreadAggr < 0) {
-    tsdbError("vgId:%d failed to load block aggr part while read file %s since %s, offset:%" PRIu64 " len :%" PRIzu,
-              TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr), tstrerror(terrno),
-              (uint64_t)pBlock->aggrOffset, sizeAggr);
+    tsdbError("vgId:%d failed to load block statis part for uid %" PRIu64
+              " while read file %s since %s, offset:%" PRIu64 " len :%" PRIzu,
+              TSDB_READ_REPO_ID(pReadh), TSDB_READ_TABLE_UID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr),
+              tstrerror(terrno), (uint64_t)pBlock->aggrOffset, sizeAggr);
     return -1;
   }
 
   if (nreadAggr < sizeAggr) {
     terrno = TSDB_CODE_TDB_FILE_CORRUPTED;
-    tsdbError("vgId:%d block aggr part in file %s is corrupted, offset:%" PRIu64 " expected bytes:%" PRIzu
-              " read bytes: %" PRId64,
-              TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr), (uint64_t)pBlock->aggrOffset, sizeAggr,
-              nreadAggr);
+    tsdbError("vgId:%d block statis part for uid %" PRIu64 " in file %s is corrupted, offset:%" PRIu64
+              " expected bytes:%" PRIzu " read bytes: %" PRId64,
+              TSDB_READ_REPO_ID(pReadh), TSDB_READ_TABLE_UID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr),
+              (uint64_t)pBlock->aggrOffset, sizeAggr, nreadAggr);
     return -1;
   }
 
   if (!taosCheckChecksumWhole((uint8_t *)(pReadh->pAggrBlkData), (uint32_t)sizeAggr)) {
     terrno = TSDB_CODE_TDB_FILE_CORRUPTED;
-    tsdbError("vgId:%d block aggr part in file %s is corrupted since wrong checksum, offset:%" PRIu64 " len :%" PRIzu,
-              TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr), (uint64_t)pBlock->aggrOffset, sizeAggr);
+    tsdbError("vgId:%d block statis part for uid %" PRIu64
+              "in file %s is corrupted since wrong checksum, offset:%" PRIu64 " len :%" PRIzu,
+              TSDB_READ_REPO_ID(pReadh), TSDB_READ_TABLE_UID(pReadh), TSDB_FILE_FULL_NAME(pDFileAggr),
+              (uint64_t)pBlock->aggrOffset, sizeAggr);
     return -1;
   }
   return 0;
@@ -367,7 +373,7 @@ static int tsdbLoadBlockOffset(SReadH *pReadh, SBlock *pBlock) {
   ASSERT(pBlock->numOfSubBlocks <= 1);
   SDFile *pDFile = (pBlock->last) ? TSDB_READ_LAST_FILE(pReadh) : TSDB_READ_DATA_FILE(pReadh);
   if (tsdbSeekDFile(pDFile, pBlock->offset, SEEK_SET) < 0) {
-    tsdbError("vgId:%d failed to load block statis part while seek file %s to offset %" PRId64 " since %s",
+    tsdbError("vgId:%d failed to load block head part while seek file %s to offset %" PRId64 " since %s",
               TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFile), (int64_t)pBlock->offset, tstrerror(terrno));
     return -1;
   }
@@ -377,14 +383,14 @@ static int tsdbLoadBlockOffset(SReadH *pReadh, SBlock *pBlock) {
 
   int64_t nread = tsdbReadDFile(pDFile, (void *)(pReadh->pBlkData), size);
   if (nread < 0) {
-    tsdbError("vgId:%d failed to load block statis part while read file %s since %s, offset:%" PRId64 " len :%" PRIzu,
+    tsdbError("vgId:%d failed to load block head part while read file %s since %s, offset:%" PRId64 " len :%" PRIzu,
               TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFile), tstrerror(terrno), (int64_t)pBlock->offset, size);
     return -1;
   }
 
   if (nread < size) {
     terrno = TSDB_CODE_TDB_FILE_CORRUPTED;
-    tsdbError("vgId:%d block statis part in file %s is corrupted, offset:%" PRId64 " expected bytes:%" PRIzu
+    tsdbError("vgId:%d block head part in file %s is corrupted, offset:%" PRId64 " expected bytes:%" PRIzu
               " read bytes: %" PRId64,
               TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFile), (int64_t)pBlock->offset, size, nread);
     return -1;
@@ -392,7 +398,7 @@ static int tsdbLoadBlockOffset(SReadH *pReadh, SBlock *pBlock) {
 
   if (!taosCheckChecksumWhole((uint8_t *)(pReadh->pBlkData), (uint32_t)size)) {
     terrno = TSDB_CODE_TDB_FILE_CORRUPTED;
-    tsdbError("vgId:%d block statis part in file %s is corrupted since wrong checksum, offset:%" PRId64 " len :%" PRIzu,
+    tsdbError("vgId:%d block head part in file %s is corrupted since wrong checksum, offset:%" PRId64 " len :%" PRIzu,
               TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFile), (int64_t)pBlock->offset, size);
     return -1;
   }
@@ -546,7 +552,7 @@ static int tsdbLoadBlockDataImpl(SReadH *pReadh, SBlock *pBlock, SDataCols *pDat
   int32_t tsize = (int32_t)tsdbBlockStatisSize(pBlock->numOfCols, (uint32_t)pBlock->blkVer);
   if (!taosCheckChecksumWhole((uint8_t *)TSDB_READ_BUF(pReadh), tsize)) {
     terrno = TSDB_CODE_TDB_FILE_CORRUPTED;
-    tsdbError("vgId:%d block statis part in file %s is corrupted since wrong checksum, offset:%" PRId64 " len :%d",
+    tsdbError("vgId:%d block head part in file %s is corrupted since wrong checksum, offset:%" PRId64 " len :%d",
               TSDB_READ_REPO_ID(pReadh), TSDB_FILE_FULL_NAME(pDFile), (int64_t)pBlock->offset, tsize);
     return -1;
   }
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 4b1c213cdd..273b7447ff 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -643,6 +643,7 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
   SSubmitMsgIter msgIter = {0};
   SSubmitBlk    *pBlock = NULL;
   SInterval      interval = {0};
+  TSKEY          lastWinSKey = INT64_MIN;
 
   if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
@@ -657,7 +658,7 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
 
     SSubmitBlkIter blkIter = {0};
     if (tInitSubmitBlkIter(pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
-      tdFreeTSmaWrapper(pSW);
+      pSW = tdFreeTSmaWrapper(pSW);
       break;
     }
 
@@ -667,31 +668,37 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
         tdFreeTSmaWrapper(pSW);
         break;
       }
-      if (pSW == NULL) {
+      if (!pSW || (pTSma->tableUid != pBlock->suid)) {
+        if (pSW) {
+          pSW = tdFreeTSmaWrapper(pSW);
+        }
         if ((pSW = metaGetSmaInfoByTable(REPO_META(pTsdb), pBlock->suid)) == NULL) {
           break;
         }
         if ((pSW->number) <= 0 || (pSW->tSma == NULL)) {
-          tdFreeTSmaWrapper(pSW);
+          pSW = tdFreeTSmaWrapper(pSW);
           break;
         }
-        pTSma = pSW->tSma;
-      }
 
-      interval.interval = pTSma->interval;
-      interval.intervalUnit = pTSma->intervalUnit;
-      interval.offset = pTSma->offset;
-      interval.precision = REPO_CFG(pTsdb)->precision;
-      interval.sliding = pTSma->sliding;
-      interval.slidingUnit = pTSma->slidingUnit;
+        pTSma = pSW->tSma;
+
+        interval.interval = pTSma->interval;
+        interval.intervalUnit = pTSma->intervalUnit;
+        interval.offset = pTSma->offset;
+        interval.precision = REPO_CFG(pTsdb)->precision;
+        interval.sliding = pTSma->sliding;
+        interval.slidingUnit = pTSma->slidingUnit;
+      }
 
       TSKEY winSKey = taosTimeTruncate(TD_ROW_KEY(row), &interval, interval.precision);
 
-      tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey, version);
-
-      // TODO: release only when suid changes.
-      tdDestroyTSmaWrapper(pSW);
-      taosMemoryFreeClear(pSW);
+      if (lastWinSKey != winSKey) {
+        lastWinSKey = winSKey;
+        tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey, version);
+      } else {
+        tsdbDebug("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window ignore as duplicated",
+                  REPO_ID(pTsdb), pTSma->indexUid, winSKey);
+      }
     }
   }
 
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index fb75ffe6b6..1c3a3787f3 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -215,10 +215,21 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
     return -1;
   }
 
+  // TODO: remove the debug log
+  SRSmaParam *param = vCreateTbReq.stbCfg.pRSmaParam;
+  if (param) {
+    printf("qmsg1 len = %d, body = %s\n", param->qmsg1 ? (int32_t)strlen(param->qmsg1) : 0,
+           param->qmsg1 ? param->qmsg1 : "");
+    printf("qmsg1 len = %d, body = %s\n", param->qmsg2 ? (int32_t)strlen(param->qmsg2) : 0,
+           param->qmsg2 ? param->qmsg2 : "");
+  }
+
   taosMemoryFree(vCreateTbReq.stbCfg.pSchema);
   taosMemoryFree(vCreateTbReq.stbCfg.pTagSchema);
   if (vCreateTbReq.stbCfg.pRSmaParam) {
     taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->pFuncIds);
+    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->qmsg1);
+    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->qmsg2);
     taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam);
   }
   taosMemoryFree(vCreateTbReq.name);
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 9e48e12cb5..5adfb7caca 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -382,7 +382,7 @@ typedef struct SSysTableScanInfo {
   void*   pCur;        // cursor for iterate the local table meta store.
   SArray* scanCols;    // SArray<int16_t> scan column id list
 
-  int32_t             type;  // show type, TODO remove it
+//  int32_t             type;  // show type, TODO remove it
   SName               name;
   SSDataBlock*        pRes;
   int32_t             capacity;
@@ -479,7 +479,7 @@ typedef struct {
 
 typedef struct SGroupbyOperatorInfo {
   SOptrBasicInfo  binfo;
-  SArray*         pGroupCols;
+  SArray*         pGroupCols;     // group by columns, SArray<SColumn>
   SArray*         pGroupColVals;  // current group column values, SArray<SGroupKeys>
   SNode*          pCondition;
   bool            isInit;       // denote if current val is initialized or not
@@ -600,7 +600,6 @@ typedef struct SJoinOperatorInfo {
   int32_t            rightPos;
   SColumnInfo        rightCol;
   SNode             *pOnCondition;
-//  SRspResultInfo     resultInfo;
 } SJoinOperatorInfo;
 
 int32_t operatorDummyOpenFn(SOperatorInfo* pOperator);
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 7791a345ed..7a7cb68424 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -1087,6 +1087,7 @@ static int32_t doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCt
     pCtx[i].currentStage = MAIN_SCAN;
 
     SInputColumnInfoData* pInput = &pCtx[i].input;
+    pInput->uid = pBlock->info.uid;
 
     SExprInfo* pOneExpr = &pOperator->pExpr[i];
     for (int32_t j = 0; j < pOneExpr->base.numOfParams; ++j) {
@@ -1101,7 +1102,9 @@ static int32_t doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCt
         pInput->pPTS = taosArrayGet(pBlock->pDataBlock, 0); // todo set the correct timestamp column
         ASSERT(pInput->pData[j] != NULL);
       } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) {
-        if (createDummyCol) {
+        // todo avoid case: top(k, 12), 12 is the value parameter.
+        // sum(11), 11 is also the value parameter.
+        if (createDummyCol && pOneExpr->base.numOfParams == 1) {
           code = doCreateConstantValColumnInfo(pInput, pFuncParam, pFuncParam->param.nType, j, pBlock->info.rows);
           if (code != TSDB_CODE_SUCCESS) {
             return code;
@@ -1876,67 +1879,58 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
         }
       }
       pCtx->resDataInfo.interBufSize = env.calcMemSize;
-    } else if (pExpr->pExpr->nodeType == QUERY_NODE_COLUMN || pExpr->pExpr->nodeType == QUERY_NODE_OPERATOR || pExpr->pExpr->nodeType == QUERY_NODE_VALUE) {
-      pCtx->resDataInfo.interBufSize = pFunct->resSchema.bytes; // for simple column, the intermediate buffer needs to hold one element.
+    } else if (pExpr->pExpr->nodeType == QUERY_NODE_COLUMN || pExpr->pExpr->nodeType == QUERY_NODE_OPERATOR ||
+               pExpr->pExpr->nodeType == QUERY_NODE_VALUE) {
+      // for simple column, the intermediate buffer needs to hold one element.
+      pCtx->resDataInfo.interBufSize = pFunct->resSchema.bytes;
     }
 
     pCtx->input.numOfInputCols = pFunct->numOfParams;
     pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
     pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
 
-    pCtx->pTsOutput         = NULL;
+    pCtx->pTsOutput = NULL;
     pCtx->resDataInfo.bytes = pFunct->resSchema.bytes;
-    pCtx->resDataInfo.type  = pFunct->resSchema.type;
-    pCtx->order             = TSDB_ORDER_ASC;
-    pCtx->start.key         = INT64_MIN;
-    pCtx->end.key           = INT64_MIN;
-#if 0
-    for (int32_t j = 0; j < pCtx->numOfParams; ++j) {
-//      int16_t type = pFunct->param[j].nType;
-//      int16_t bytes = pFunct->param[j].nLen;
+    pCtx->resDataInfo.type = pFunct->resSchema.type;
+    pCtx->order = TSDB_ORDER_ASC;
+    pCtx->start.key = INT64_MIN;
+    pCtx->end.key = INT64_MIN;
+    pCtx->numOfParams = pExpr->base.numOfParams;
 
-//      if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-//        taosVariantCreateFromBinary(&pCtx->param[j], pFunct->param[j].pz, bytes, type);
-//      } else {
-//        taosVariantCreateFromBinary(&pCtx->param[j], (char *)&pFunct->param[j].i, bytes, type);
+    pCtx->param = pFunct->pParam;
+//    for (int32_t j = 0; j < pCtx->numOfParams; ++j) {
+//      // set the order information for top/bottom query
+//      int32_t functionId = pCtx->functionId;
+//      if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF) {
+//        int32_t f = getExprFunctionId(&pExpr[0]);
+//        assert(f == FUNCTION_TS || f == FUNCTION_TS_DUMMY);
+//
+//        //      pCtx->param[2].i = pQueryAttr->order.order;
+//        //      pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
+//        //      pCtx->param[3].i = functionId;
+//        //      pCtx->param[3].nType = TSDB_DATA_TYPE_BIGINT;
+//
+//        //      pCtx->param[1].i = pQueryAttr->order.col.info.colId;
+//      } else if (functionId == FUNCTION_INTERP) {
+//        //      pCtx->param[2].i = (int8_t)pQueryAttr->fillType;
+//        //      if (pQueryAttr->fillVal != NULL) {
+//        //        if (isNull((const char *)&pQueryAttr->fillVal[i], pCtx->inputType)) {
+//        //          pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
+//        //        } else {  // todo refactor, taosVariantCreateFromBinary should handle the NULL value
+//        //          if (pCtx->inputType != TSDB_DATA_TYPE_BINARY && pCtx->inputType != TSDB_DATA_TYPE_NCHAR) {
+//        //            taosVariantCreateFromBinary(&pCtx->param[1], (char *)&pQueryAttr->fillVal[i], pCtx->inputBytes, pCtx->inputType);
+//        //          }
+//        //        }
+//        //      }
+//      } else if (functionId == FUNCTION_TWA) {
+//        //      pCtx->param[1].i = pQueryAttr->window.skey;
+//        //      pCtx->param[1].nType = TSDB_DATA_TYPE_BIGINT;
+//        //      pCtx->param[2].i = pQueryAttr->window.ekey;
+//        //      pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
+//      } else if (functionId == FUNCTION_ARITHM) {
+//        //      pCtx->param[1].pz = (char*) getScalarFuncSupport(pRuntimeEnv->scalarSup, i);
 //      }
-    }
-
-    // set the order information for top/bottom query
-    int32_t functionId = pCtx->functionId;
-    if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF) {
-      int32_t f = getExprFunctionId(&pExpr[0]);
-      assert(f == FUNCTION_TS || f == FUNCTION_TS_DUMMY);
-
-//      pCtx->param[2].i = pQueryAttr->order.order;
-      pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
-      pCtx->param[3].i = functionId;
-      pCtx->param[3].nType = TSDB_DATA_TYPE_BIGINT;
-
-//      pCtx->param[1].i = pQueryAttr->order.col.info.colId;
-    } else if (functionId == FUNCTION_INTERP) {
-//      pCtx->param[2].i = (int8_t)pQueryAttr->fillType;
-//      if (pQueryAttr->fillVal != NULL) {
-//        if (isNull((const char *)&pQueryAttr->fillVal[i], pCtx->inputType)) {
-//          pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
-//        } else {  // todo refactor, taosVariantCreateFromBinary should handle the NULL value
-//          if (pCtx->inputType != TSDB_DATA_TYPE_BINARY && pCtx->inputType != TSDB_DATA_TYPE_NCHAR) {
-//            taosVariantCreateFromBinary(&pCtx->param[1], (char *)&pQueryAttr->fillVal[i], pCtx->inputBytes, pCtx->inputType);
-//          }
-//        }
-//      }
-    } else if (functionId == FUNCTION_TS_COMP) {
-//      pCtx->param[0].i = pQueryAttr->vgId;  //TODO this should be the parameter from client
-      pCtx->param[0].nType = TSDB_DATA_TYPE_BIGINT;
-    } else if (functionId == FUNCTION_TWA) {
-//      pCtx->param[1].i = pQueryAttr->window.skey;
-      pCtx->param[1].nType = TSDB_DATA_TYPE_BIGINT;
-//      pCtx->param[2].i = pQueryAttr->window.ekey;
-      pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
-    } else if (functionId == FUNCTION_ARITHM) {
-//      pCtx->param[1].pz = (char*) getScalarFuncSupport(pRuntimeEnv->scalarSup, i);
-    }
-#endif
+//    }
   }
 
   for (int32_t i = 1; i < numOfOutput; ++i) {
@@ -1955,7 +1949,7 @@ static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, int32_t numOfOutput) {
 
   for (int32_t i = 0; i < numOfOutput; ++i) {
     for (int32_t j = 0; j < pCtx[i].numOfParams; ++j) {
-      taosVariantDestroy(&pCtx[i].param[j]);
+      taosVariantDestroy(&pCtx[i].param[j].param);
     }
 
     taosVariantDestroy(&pCtx[i].tag);
@@ -6487,9 +6481,6 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
 
       int32_t     numOfCols = 0;
       tsdbReaderT pDataReader = doCreateDataReader(pTableScanNode, pHandle, pTableGroupInfo, (uint64_t)queryId, taskId);
-      if (pDataReader == NULL) {
-        return NULL;
-      }
 
       SArray* pColList = extractColMatchInfo(pScanPhyNode->pScanCols, pScanPhyNode->node.pOutputDataBlockDesc, &numOfCols);
       SSDataBlock* pResBlock = createResDataBlock(pScanPhyNode->node.pOutputDataBlockDesc);
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index f0d3d95b6a..ce3de02c9f 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -30,12 +30,11 @@
 #include "query.h"
 #include "tcompare.h"
 #include "thash.h"
-#include "vnode.h"
 #include "ttypes.h"
+#include "vnode.h"
 
 #define SET_REVERSE_SCAN_FLAG(_info) ((_info)->scanFlag = REVERSE_SCAN)
-#define SWITCH_ORDER(n)           (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
-
+#define SWITCH_ORDER(n)              (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
 
 void switchCtxOrder(SqlFunctionCtx* pCtx, int32_t numOfOutput) {
   for (int32_t i = 0; i < numOfOutput; ++i) {
@@ -90,7 +89,7 @@ static void getNextTimeWindow(SInterval* pInterval, STimeWindow* tw, int32_t ord
   }
 
   int64_t key = tw->skey, interval = pInterval->interval;
-  //convert key to second
+  // convert key to second
   key = convertTimePrecision(key, pInterval->precision, TSDB_TIME_PRECISION_MILLI) / 1000;
 
   if (pInterval->intervalUnit == 'y') {
@@ -98,7 +97,7 @@ static void getNextTimeWindow(SInterval* pInterval, STimeWindow* tw, int32_t ord
   }
 
   struct tm tm;
-  time_t t = (time_t)key;
+  time_t    t = (time_t)key;
   taosLocalTime(&t, &tm);
 
   int mon = (int)(tm.tm_year * 12 + tm.tm_mon + interval * factor);
@@ -125,8 +124,8 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
   // todo handle the time range case
   TSKEY sk = INT64_MIN;
   TSKEY ek = INT64_MAX;
-//  TSKEY sk = MIN(pQueryAttr->window.skey, pQueryAttr->window.ekey);
-//  TSKEY ek = MAX(pQueryAttr->window.skey, pQueryAttr->window.ekey);
+  //  TSKEY sk = MIN(pQueryAttr->window.skey, pQueryAttr->window.ekey);
+  //  TSKEY ek = MAX(pQueryAttr->window.skey, pQueryAttr->window.ekey);
 
   if (true) {
     getAlignQueryTimeWindow(pInterval, pInterval->precision, pBlockInfo->window.skey, &w);
@@ -136,7 +135,7 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
       return true;
     }
 
-    while(1) { // todo handle the desc order scan case
+    while (1) {  // todo handle the desc order scan case
       getNextTimeWindow(pInterval, &w, TSDB_ORDER_ASC);
       if (w.skey > pBlockInfo->window.ekey) {
         break;
@@ -148,31 +147,31 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
       }
     }
   } else {
-//    getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.ekey, sk, ek, &w);
-//    assert(w.skey <= pBlockInfo->window.ekey);
-//
-//    if (w.skey > pBlockInfo->window.skey) {
-//      return true;
-//    }
-//
-//    while(1) {
-//      getNextTimeWindow(pQueryAttr, &w);
-//      if (w.ekey < pBlockInfo->window.skey) {
-//        break;
-//      }
-//
-//      assert(w.skey < pBlockInfo->window.skey);
-//      if (w.ekey < pBlockInfo->window.ekey && w.ekey >= pBlockInfo->window.skey) {
-//        return true;
-//      }
-//    }
+    //    getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.ekey, sk, ek, &w);
+    //    assert(w.skey <= pBlockInfo->window.ekey);
+    //
+    //    if (w.skey > pBlockInfo->window.skey) {
+    //      return true;
+    //    }
+    //
+    //    while(1) {
+    //      getNextTimeWindow(pQueryAttr, &w);
+    //      if (w.ekey < pBlockInfo->window.skey) {
+    //        break;
+    //      }
+    //
+    //      assert(w.skey < pBlockInfo->window.skey);
+    //      if (w.ekey < pBlockInfo->window.ekey && w.ekey >= pBlockInfo->window.skey) {
+    //        return true;
+    //      }
+    //    }
   }
 
   return false;
 }
 
 int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableScanInfo, SSDataBlock* pBlock, uint32_t* status) {
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
   STableScanInfo* pInfo = pOperator->info;
 
   STaskCostInfo* pCost = &pTaskInfo->cost;
@@ -189,13 +188,13 @@ int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableScanInfo,
   taosMemoryFreeClear(pBlock->pBlockAgg);
 
   if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {
-    qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo), pBlockInfo->window.skey,
-           pBlockInfo->window.ekey, pBlockInfo->rows);
+    qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
+           pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
     pCost->filterOutBlocks += 1;
     return TSDB_CODE_SUCCESS;
   } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {
-    qDebug("%s data block skipped, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo), pBlockInfo->window.skey,
-           pBlockInfo->window.ekey, pBlockInfo->rows);
+    qDebug("%s data block skipped, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
+           pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
     pCost->skipBlocks += 1;
     return TSDB_CODE_SUCCESS;
   } else if (*status == FUNC_DATA_REQUIRED_STATIS_LOAD) {
@@ -218,12 +217,12 @@ int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableScanInfo,
       }
 
       return TSDB_CODE_SUCCESS;
-    } else { // failed to load the block sma data, data block statistics does not exist, load data block instead
+    } else {  // failed to load the block sma data, data block statistics does not exist, load data block instead
       *status = FUNC_DATA_REQUIRED_DATA_LOAD;
     }
   }
 
-  ASSERT (*status == FUNC_DATA_REQUIRED_DATA_LOAD);
+  ASSERT(*status == FUNC_DATA_REQUIRED_DATA_LOAD);
 
   // todo filter data block according to the block sma data firstly
 #if 0
@@ -249,8 +248,8 @@ int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableScanInfo,
   doFilter(pTableScanInfo->pFilterNode, pBlock);
   if (pBlock->info.rows == 0) {
     pCost->filterOutBlocks += 1;
-    qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo), pBlockInfo->window.skey,
-           pBlockInfo->window.ekey, pBlockInfo->rows);
+    qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
+           pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -320,7 +319,7 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator, bool* newgroup) {
   SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
 
   // The read handle is not initialized yet, since no qualified tables exists
-  if (pTableScanInfo->dataReader == NULL) {
+  if (pTableScanInfo->dataReader == NULL || pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
 
@@ -348,9 +347,9 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator, bool* newgroup) {
     setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);
     pTableScanInfo->scanFlag = REPEAT_SCAN;
 
-//    if (pResultRowInfo->size > 0) {
-//      pResultRowInfo->curPos = 0;
-//    }
+    //    if (pResultRowInfo->size > 0) {
+    //      pResultRowInfo->curPos = 0;
+    //    }
 
     qDebug("%s start to repeat scan data blocks due to query func required, qrange:%" PRId64 "-%" PRId64,
            GET_TASKID(pTaskInfo), pTaskInfo->window.skey, pTaskInfo->window.ekey);
@@ -367,7 +366,7 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator, bool* newgroup) {
            GET_TASKID(pTaskInfo), pTaskInfo->window.skey, pTaskInfo->window.ekey);
 
     if (pResultRowInfo->size > 0) {
-//      pResultRowInfo->curPos = pResultRowInfo->size - 1;
+      //      pResultRowInfo->curPos = pResultRowInfo->size - 1;
     }
 
     p = doTableScanImpl(pOperator, newgroup);
@@ -376,7 +375,7 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator, bool* newgroup) {
   return p;
 }
 
-SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, int32_t dataLoadFlag,
+SOperatorInfo* createTableScanOperatorInfo(void* pDataReader, int32_t order, int32_t numOfOutput, int32_t dataLoadFlag,
                                            int32_t repeatTime, int32_t reverseTime, SArray* pColMatchInfo, SSDataBlock* pResBlock,
                                            SNode* pCondition, SInterval* pInterval, double sampleRatio, SExecTaskInfo* pTaskInfo) {
   assert(repeatTime > 0);
@@ -396,7 +395,7 @@ SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order,
   pInfo->dataBlockLoadFlag= dataLoadFlag;
   pInfo->pResBlock        = pResBlock;
   pInfo->pFilterNode      = pCondition;
-  pInfo->dataReader       = pTsdbReadHandle;
+  pInfo->dataReader       = pDataReader;
   pInfo->times            = repeatTime;
   pInfo->reverseTimes     = reverseTime;
   pInfo->order            = order;
@@ -406,11 +405,11 @@ SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order,
   pOperator->name         = "TableScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN;
   pOperator->blockingOptr = false;
-  pOperator->status       = OP_NOT_OPENED;
-  pOperator->info         = pInfo;
-  pOperator->numOfOutput  = numOfOutput;
-  pOperator->getNextFn    = doTableScan;
-  pOperator->pTaskInfo    = pTaskInfo;
+  pOperator->status = OP_NOT_OPENED;
+  pOperator->info = pInfo;
+  pOperator->numOfOutput = numOfOutput;
+  pOperator->getNextFn = doTableScan;
+  pOperator->pTaskInfo = pTaskInfo;
 
   static int32_t cost = 0;
   pOperator->cost.openCost = ++cost;
@@ -456,67 +455,67 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator, bool* newgroup) {
     ++numRowSteps;
   }
 
-  tableBlockDist.dataBlockInfos  = taosArrayInit(numRowSteps, sizeof(SFileBlockInfo));
+  tableBlockDist.dataBlockInfos = taosArrayInit(numRowSteps, sizeof(SFileBlockInfo));
   taosArraySetSize(tableBlockDist.dataBlockInfos, numRowSteps);
 
   tableBlockDist.maxRows = INT_MIN;
   tableBlockDist.minRows = INT_MAX;
 
   tsdbGetFileBlocksDistInfo(pTableScanInfo->dataReader, &tableBlockDist);
-  tableBlockDist.numOfRowsInMemTable = (int32_t) tsdbGetNumOfRowsInMemTable(pTableScanInfo->dataReader);
+  tableBlockDist.numOfRowsInMemTable = (int32_t)tsdbGetNumOfRowsInMemTable(pTableScanInfo->dataReader);
 
   SSDataBlock* pBlock = pTableScanInfo->pResBlock;
-  pBlock->info.rows   = 1;
+  pBlock->info.rows = 1;
   pBlock->info.numOfCols = 1;
 
-//  SBufferWriter bw = tbufInitWriter(NULL, false);
-//  blockDistInfoToBinary(&tableBlockDist, &bw);
+  //  SBufferWriter bw = tbufInitWriter(NULL, false);
+  //  blockDistInfoToBinary(&tableBlockDist, &bw);
   SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, 0);
 
-//  int32_t len = (int32_t) tbufTell(&bw);
-//  pColInfo->pData = taosMemoryMalloc(len + sizeof(int32_t));
-//  *(int32_t*) pColInfo->pData = len;
-//  memcpy(pColInfo->pData + sizeof(int32_t), tbufGetData(&bw, false), len);
-//
-//  tbufCloseWriter(&bw);
+  //  int32_t len = (int32_t) tbufTell(&bw);
+  //  pColInfo->pData = taosMemoryMalloc(len + sizeof(int32_t));
+  //  *(int32_t*) pColInfo->pData = len;
+  //  memcpy(pColInfo->pData + sizeof(int32_t), tbufGetData(&bw, false), len);
+  //
+  //  tbufCloseWriter(&bw);
 
-//  SArray* g = GET_TABLEGROUP(pOperator->, 0);
-//  pOperator->pRuntimeEnv->current = taosArrayGetP(g, 0);
+  //  SArray* g = GET_TABLEGROUP(pOperator->, 0);
+  //  pOperator->pRuntimeEnv->current = taosArrayGetP(g, 0);
 
   pOperator->status = OP_EXEC_DONE;
   return pBlock;
 }
 
 SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SExecTaskInfo* pTaskInfo) {
-  STableScanInfo* pInfo    = taosMemoryCalloc(1, sizeof(STableScanInfo));
-  SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo));
+  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
     pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
     goto _error;
   }
 
-  pInfo->dataReader       = dataReader;
-//  pInfo->block.pDataBlock = taosArrayInit(1, sizeof(SColumnInfoData));
+  pInfo->dataReader = dataReader;
+  //  pInfo->block.pDataBlock = taosArrayInit(1, sizeof(SColumnInfoData));
 
   SColumnInfoData infoData = {0};
-  infoData.info.type  = TSDB_DATA_TYPE_BINARY;
+  infoData.info.type = TSDB_DATA_TYPE_BINARY;
   infoData.info.bytes = 1024;
   infoData.info.colId = 0;
-//  taosArrayPush(pInfo->block.pDataBlock, &infoData);
+  //  taosArrayPush(pInfo->block.pDataBlock, &infoData);
 
-  pOperator->name          = "DataBlockInfoScanOperator";
+  pOperator->name = "DataBlockInfoScanOperator";
   //  pOperator->operatorType = OP_TableBlockInfoScan;
-  pOperator->blockingOptr  = false;
-  pOperator->status        = OP_NOT_OPENED;
-  pOperator->_openFn       = operatorDummyOpenFn;
-  pOperator->getNextFn     = doBlockInfoScan;
+  pOperator->blockingOptr = false;
+  pOperator->status = OP_NOT_OPENED;
+  pOperator->_openFn = operatorDummyOpenFn;
+  pOperator->getNextFn = doBlockInfoScan;
 
-  pOperator->info          = pInfo;
-  pOperator->pTaskInfo     = pTaskInfo;
+  pOperator->info = pInfo;
+  pOperator->pTaskInfo = pTaskInfo;
 
   return pOperator;
 
-  _error:
+_error:
   taosMemoryFreeClear(pInfo);
   taosMemoryFreeClear(pOperator);
   return NULL;
@@ -558,29 +557,42 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup)
     blockDataCleanup(pInfo->pRes);
 
     while (tqNextDataBlock(pInfo->readerHandle)) {
-      pTaskInfo->code = tqRetrieveDataBlockInfo(pInfo->readerHandle, pBlockInfo);
-      if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
-        terrno = pTaskInfo->code;
-        pOperator->status = OP_EXEC_DONE;
+      SArray*  pCols = NULL;
+      uint64_t groupId;
+      int32_t  numOfRows;
+      int32_t  code = tqRetrieveDataBlock(&pCols, pInfo->readerHandle, &groupId, &numOfRows);
+
+      if (code != TSDB_CODE_SUCCESS || numOfRows == 0) {
+        pTaskInfo->code = code;
         return NULL;
       }
 
-      if (pBlockInfo->rows == 0) {
-        break;
-      }
-
-      SArray* pCols = tqRetrieveDataBlock(pInfo->readerHandle);
+      pInfo->pRes->info.groupId = groupId;
+      pInfo->pRes->info.rows = numOfRows;
 
       int32_t numOfCols = pInfo->pRes->info.numOfCols;
       for (int32_t i = 0; i < numOfCols; ++i) {
-        SColumnInfoData* p = taosArrayGet(pCols, i);
-        SColMatchInfo*   pColMatchInfo = taosArrayGet(pInfo->pColMatchInfo, i);
+        SColMatchInfo* pColMatchInfo = taosArrayGet(pInfo->pColMatchInfo, i);
         if (!pColMatchInfo->output) {
           continue;
         }
 
-        ASSERT(pColMatchInfo->colId == p->info.colId);
-        taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, p);
+        bool colExists = false;
+        for (int32_t j = 0; j < taosArrayGetSize(pCols); ++j) {
+          SColumnInfoData* pResCol = taosArrayGet(pCols, j);
+          if (pResCol->info.colId == pColMatchInfo->colId) {
+            taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
+            colExists = true;
+            break;
+          }
+        }
+
+        // the required column does not exists in submit block, let's set it to be all null value
+        if (!colExists) {
+          SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId);
+          colInfoDataEnsureCapacity(pDst, 0, pBlockInfo->rows);
+          colDataAppendNNULL(pDst, 0, pBlockInfo->rows);
+        }
       }
 
       if (pInfo->pRes->pDataBlock == NULL) {
@@ -605,7 +617,8 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup)
   }
 }
 
-SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock* pResBlock, SArray* pColList, SArray* pTableIdList, SExecTaskInfo* pTaskInfo) {
+SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock* pResBlock, SArray* pColList,
+                                            SArray* pTableIdList, SExecTaskInfo* pTaskInfo) {
   SStreamBlockScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamBlockScanInfo));
   SOperatorInfo*        pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -618,7 +631,7 @@ SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock*
   int32_t numOfOutput = taosArrayGetSize(pColList);
 
   SArray* pColIds = taosArrayInit(4, sizeof(int16_t));
-  for(int32_t i = 0; i < numOfOutput; ++i) {
+  for (int32_t i = 0; i < numOfOutput; ++i) {
     int16_t* id = taosArrayGet(pColList, i);
     taosArrayPush(pColIds, id);
   }
@@ -644,16 +657,16 @@ SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock*
   pInfo->readerHandle = streamReadHandle;
   pInfo->pRes = pResBlock;
 
-  pOperator->name         = "StreamBlockScanOperator";
+  pOperator->name = "StreamBlockScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN;
   pOperator->blockingOptr = false;
-  pOperator->status       = OP_NOT_OPENED;
-  pOperator->info         = pInfo;
-  pOperator->numOfOutput  = pResBlock->info.numOfCols;
-  pOperator->_openFn      = operatorDummyOpenFn;
-  pOperator->getNextFn    = doStreamBlockScan;
-  pOperator->closeFn      = operatorDummyCloseFn;
-  pOperator->pTaskInfo    = pTaskInfo;
+  pOperator->status = OP_NOT_OPENED;
+  pOperator->info = pInfo;
+  pOperator->numOfOutput = pResBlock->info.numOfCols;
+  pOperator->_openFn = operatorDummyOpenFn;
+  pOperator->getNextFn = doStreamBlockScan;
+  pOperator->closeFn = operatorDummyCloseFn;
+  pOperator->pTaskInfo = pTaskInfo;
 
   return pOperator;
 }
@@ -663,7 +676,8 @@ static void destroySysScanOperator(void* param, int32_t numOfOutput) {
   tsem_destroy(&pInfo->ready);
   blockDataDestroy(pInfo->pRes);
 
-  if (pInfo->type == TSDB_MGMT_TABLE_TABLE) {
+  const char* name = tNameGetTableName(&pInfo->name);
+  if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLES, TSDB_TABLE_FNAME_LEN) == 0) {
     metaCloseTbCursor(pInfo->pCur);
   }
 }
@@ -733,9 +747,9 @@ static int32_t loadSysTableContentCb(void* param, const SDataBuf* pMsg, int32_t
 
     SRetrieveMetaTableRsp* pRsp = pScanResInfo->pRsp;
     pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->useconds  = htobe64(pRsp->useconds);
-    pRsp->handle    = htobe64(pRsp->handle);
-    pRsp->compLen   = htonl(pRsp->compLen);
+    pRsp->useconds = htobe64(pRsp->useconds);
+    pRsp->handle = htobe64(pRsp->handle);
+    pRsp->compLen = htonl(pRsp->compLen);
   } else {
     operator->pTaskInfo->code = code;
   }
@@ -777,7 +791,7 @@ static SSDataBlock* doFilterResult(SSysTableScanInfo* pInfo) {
         if (rowRes[j] == 0) {
           continue;
         }
-      
+
         colDataAppend(pDest, numOfRow, colDataGetData(pSrc, j), false);
         numOfRow += 1;
       }
@@ -798,7 +812,8 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator, bool* newgroup) {
   SSysTableScanInfo* pInfo = pOperator->info;
 
   // retrieve local table list info from vnode
-  if (pInfo->type == TSDB_MGMT_TABLE_TABLE) {
+  const char* name = tNameGetTableName(&pInfo->name);
+  if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLES, TSDB_TABLE_FNAME_LEN) == 0) {
     if (pInfo->pCur == NULL) {
       pInfo->pCur = metaOpenTbCursor(pInfo->readHandle);
     }
@@ -828,7 +843,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator, bool* newgroup) {
         SColumnInfoData* pColInfoData = taosArrayGet(pInfo->pRes->pDataBlock, i);
         int64_t          tmp = 0;
         char             t[10] = {0};
-        STR_TO_VARSTR(t, "_");  //TODO
+        STR_TO_VARSTR(t, "_");  // TODO
         if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
           colDataAppend(pColInfoData, numOfRows, t, false);
         } else {
@@ -850,8 +865,6 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator, bool* newgroup) {
 
     while (1) {
       int64_t startTs = taosGetTimestampUs();
-
-      pInfo->req.type = pInfo->type;
       strncpy(pInfo->req.tb, tNameGetTableName(&pInfo->name), tListLen(pInfo->req.tb));
 
       if (pInfo->showRewrite) {
@@ -926,75 +939,16 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB
     return NULL;
   }
 
-  pInfo->accountId   = accountId;
+  pInfo->accountId = accountId;
   pInfo->showRewrite = showRewrite;
-  pInfo->pRes        = pResBlock;
-  pInfo->capacity    = 4096;
-  pInfo->pCondition  = pCondition;
-  pInfo->scanCols    = colList;
-
-  // TODO remove it
-  int32_t     tableType = 0;
-  const char* name = tNameGetTableName(pName);
-  if (strncasecmp(name, TSDB_INS_TABLE_DNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_DNODE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_MNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_MNODE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_MODULES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_MODULE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_QNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_QNODE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_BNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_BNODE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_SNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_SNODE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_CLUSTER, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_CLUSTER;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_DATABASES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_DB;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_FUNCTIONS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_FUNC;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_INDEXES, tListLen(pName->tname)) == 0) {
-    //    tableType = TSDB_MGMT_TABLE_INDEX;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STABLES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_STB;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STREAMS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_STREAMS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_TABLE;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED, tListLen(pName->tname)) == 0) {
-    //    tableType = TSDB_MGMT_TABLE_DIST;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USER_USERS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_USER;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_LICENCES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_GRANTS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_VGROUPS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_VGROUP;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_TOPICS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_TOPICS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_CONSUMERS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_CONSUMERS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_SUBSCRIBES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_SUBSCRIBES;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_TRANS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_TRANS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_SMAS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_SMAS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_CONFIGS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_CONFIGS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_CONNS, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_CONNS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_QUERIES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_QUERIES;
-  }  else if (strncasecmp(name, TSDB_INS_TABLE_VNODES, tListLen(pName->tname)) == 0) {
-    tableType = TSDB_MGMT_TABLE_VNODES;
-  }else {
-    ASSERT(0);
-  }
+  pInfo->pRes = pResBlock;
+  pInfo->capacity = 4096;
+  pInfo->pCondition = pCondition;
+  pInfo->scanCols = colList;
 
   tNameAssign(&pInfo->name, pName);
-  pInfo->type = tableType;
-  if (pInfo->type == TSDB_MGMT_TABLE_TABLE) {
+  const char* name = tNameGetTableName(&pInfo->name);
+  if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLES, TSDB_TABLE_FNAME_LEN) == 0) {
     pInfo->readHandle = pSysTableReadHandle;
     blockDataEnsureCapacity(pInfo->pRes, pInfo->capacity);
   } else {
@@ -1025,15 +979,15 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB
 #endif
   }
 
-  pOperator->name         = "SysTableScanOperator";
+  pOperator->name = "SysTableScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN;
   pOperator->blockingOptr = false;
-  pOperator->status       = OP_NOT_OPENED;
-  pOperator->info         = pInfo;
-  pOperator->numOfOutput  = pResBlock->info.numOfCols;
-  pOperator->getNextFn    = doSysTableScan;
-  pOperator->closeFn      = destroySysScanOperator;
-  pOperator->pTaskInfo    = pTaskInfo;
+  pOperator->status = OP_NOT_OPENED;
+  pOperator->info = pInfo;
+  pOperator->numOfOutput = pResBlock->info.numOfCols;
+  pOperator->getNextFn = doSysTableScan;
+  pOperator->closeFn = destroySysScanOperator;
+  pOperator->pTaskInfo = pTaskInfo;
 
   return pOperator;
 }
diff --git a/source/libs/function/inc/builtinsimpl.h b/source/libs/function/inc/builtinsimpl.h
index 11c89f1568..8473138e4a 100644
--- a/source/libs/function/inc/builtinsimpl.h
+++ b/source/libs/function/inc/builtinsimpl.h
@@ -58,6 +58,9 @@ bool getFirstLastFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 int32_t firstFunction(SqlFunctionCtx *pCtx);
 int32_t lastFunction(SqlFunctionCtx *pCtx);
 
+bool getTopBotFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv);
+int32_t topFunction(SqlFunctionCtx *pCtx);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/libs/function/inc/tudf.h b/source/libs/function/inc/tudf.h
index c51b6e1264..b5c839c811 100644
--- a/source/libs/function/inc/tudf.h
+++ b/source/libs/function/inc/tudf.h
@@ -27,41 +27,31 @@ extern "C" {
 #endif
 
 #define UDF_LISTEN_PIPE_NAME_LEN 32
-#define UDF_LISTEN_PIPE_NAME_PREFIX "udf.sock."
+#define UDF_LISTEN_PIPE_NAME_PREFIX "udfd.sock."
 
 //======================================================================================
 //begin API to taosd and qworker
 
 enum {
   UDFC_CODE_STOPPING = -1,
-  UDFC_CODE_RESTARTING = -2,
   UDFC_CODE_PIPE_READ_ERR = -3,
 };
 
-/*TODO: no api for dnode startudfd/stopudfd*/
-/**
- * start udfd dameon service
- */
-int32_t startUdfd(int32_t dnodeId);
-
-/**
- * stop udfd dameon service
- */
-int32_t stopUdfd(int32_t dnodeId);
+typedef void *UdfcHandle;
+typedef void *UdfcFuncHandle;
 
 /**
  * create udfd proxy, called once in process that call setupUdf/callUdfxxx/teardownUdf
  * @return error code
  */
-int32_t createUdfdProxy(int32_t dnodeId);
+int32_t udfcOpen(int32_t dnodeId, UdfcHandle* proxyHandle);
 
 /**
  * destroy udfd proxy
  * @return error code
  */
-int32_t destroyUdfdProxy(int32_t dnodeId);
+int32_t udfcClose(UdfcHandle proxyhandle);
 
-typedef void *UdfHandle;
 
 /**
  * setup udf
@@ -69,7 +59,7 @@ typedef void *UdfHandle;
  * @param handle, out
  * @return error code
  */
-int32_t setupUdf(char udfName[], SEpSet *epSet, UdfHandle *handle);
+int32_t setupUdf(UdfcHandle proxyHandle, char udfName[], SEpSet *epSet, UdfcFuncHandle *handle);
 
 typedef struct SUdfColumnMeta {
   int16_t type;
@@ -116,26 +106,26 @@ typedef struct SUdfInterBuf {
 } SUdfInterBuf;
 
 // output: interBuf
-int32_t callUdfAggInit(UdfHandle handle, SUdfInterBuf *interBuf);
+int32_t callUdfAggInit(UdfcFuncHandle handle, SUdfInterBuf *interBuf);
 // input: block, state
 // output: newState
-int32_t callUdfAggProcess(UdfHandle handle, SSDataBlock *block, SUdfInterBuf *state, SUdfInterBuf *newState);
+int32_t callUdfAggProcess(UdfcFuncHandle handle, SSDataBlock *block, SUdfInterBuf *state, SUdfInterBuf *newState);
 // input: interBuf
 // output: resultData
-int32_t callUdfAggFinalize(UdfHandle handle, SUdfInterBuf *interBuf, SUdfInterBuf *resultData);
+int32_t callUdfAggFinalize(UdfcFuncHandle handle, SUdfInterBuf *interBuf, SUdfInterBuf *resultData);
 // input: interbuf1, interbuf2
 // output: resultBuf
-int32_t callUdfAggMerge(UdfHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2, SUdfInterBuf *resultBuf);
+int32_t callUdfAggMerge(UdfcFuncHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2, SUdfInterBuf *resultBuf);
 // input: block
 // output: resultData
-int32_t callUdfScalaProcess(UdfHandle handle, SSDataBlock *block, SSDataBlock *resultData);
+int32_t callUdfScalaProcess(UdfcFuncHandle handle, SSDataBlock *block, SSDataBlock *resultData);
 
 /**
  * tearn down udf
  * @param handle
  * @return
  */
-int32_t teardownUdf(UdfHandle handle);
+int32_t teardownUdf(UdfcFuncHandle handle);
 
 // end API to taosd and qworker
 //=============================================================================================================================
diff --git a/source/libs/function/inc/udfc.h b/source/libs/function/inc/udfc.h
index fed2818ced..1cf8c67686 100644
--- a/source/libs/function/inc/udfc.h
+++ b/source/libs/function/inc/udfc.h
@@ -30,20 +30,20 @@ typedef struct SUdfInfo {
     char *path;
 } SUdfInfo;
 
-typedef void *UdfHandle;
+typedef void *UdfcFuncHandle;
 
 int32_t createUdfdProxy();
 
 int32_t destroyUdfdProxy();
 
-//int32_t setupUdf(SUdfInfo *udf, int32_t numOfUdfs, UdfHandle *handles);
+//int32_t setupUdf(SUdfInfo *udf, int32_t numOfUdfs, UdfcFuncHandle *handles);
 
-int32_t setupUdf(SUdfInfo* udf, UdfHandle* handle);
+int32_t setupUdf(SUdfInfo* udf, UdfcFuncHandle* handle);
 
-int32_t callUdf(UdfHandle handle, int8_t step, char *state, int32_t stateSize, SSDataBlock input, char **newstate,
+int32_t callUdf(UdfcFuncHandle handle, int8_t step, char *state, int32_t stateSize, SSDataBlock input, char **newstate,
                 int32_t *newStateSize, SSDataBlock *output);
 
-int32_t teardownUdf(UdfHandle handle);
+int32_t teardownUdf(UdfcFuncHandle handle);
 
 typedef struct SUdfSetupRequest {
     char udfName[16]; //
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index ce7384cbbe..efd8de84c4 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -193,8 +193,15 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t translateTbnameColumn(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
+  // pseudo column do not need to check parameters
+  pFunc->node.resType = (SDataType){.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR};
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateTop(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  // todo
+  SDataType* pType = &((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType;
+  pFunc->node.resType = (SDataType){.bytes = pType->bytes, .type = pType->type};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -497,9 +504,9 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .type = FUNCTION_TYPE_TOP,
     .classification = FUNC_MGT_AGG_FUNC,
     .translateFunc = translateTop,
-    .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = maxFunctionSetup,
-    .processFunc  = maxFunction,
+    .getEnvFunc   = getTopBotFuncEnv,
+    .initFunc     = functionSetup,
+    .processFunc  = topFunction,
     .finalizeFunc = functionFinalize
   },
   {
@@ -876,7 +883,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .name = "tbname",
     .type = FUNCTION_TYPE_TBNAME,
     .classification = FUNC_MGT_PSEUDO_COLUMN_FUNC,
-    .translateFunc = NULL,
+    .translateFunc = translateTbnameColumn,
     .getEnvFunc   = NULL,
     .initFunc     = NULL,
     .sprocessFunc = NULL,
@@ -914,7 +921,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
   },
   {
     .name = "_wendts",
-    .type = FUNCTION_TYPE_QENDTS,
+    .type = FUNCTION_TYPE_WENDTS,
     .classification = FUNC_MGT_PSEUDO_COLUMN_FUNC | FUNC_MGT_WINDOW_PC_FUNC,
     .translateFunc = translateTimePseudoColumn,
     .getEnvFunc   = getTimePseudoFuncEnv,
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 3d796515a0..0942726588 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -14,10 +14,11 @@
  */
 
 #include "builtinsimpl.h"
-#include "tpercentile.h"
+#include <libs/nodes/querynodes.h>
 #include "querynodes.h"
 #include "taggfunction.h"
 #include "tdatablock.h"
+#include "tpercentile.h"
 
 #define SET_VAL(_info, numOfElem, res)  \
   do {                                  \
@@ -472,17 +473,6 @@ int32_t maxFunction(SqlFunctionCtx *pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
-typedef struct STopBotRes {
-  int32_t num;
-} STopBotRes;
-
-bool getTopBotFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
-    SColumnNode* pColNode = (SColumnNode*) nodesListGetNode(pFunc->pParameterList, 0);
-  int32_t bytes = pColNode->node.resType.bytes;
-  SValueNode* pkNode = (SValueNode*) nodesListGetNode(pFunc->pParameterList, 1);
-  return true;
-}
-
 typedef struct SStddevRes {
   double  result;
   int64_t count;
@@ -523,7 +513,7 @@ int32_t stddevFunction(SqlFunctionCtx* pCtx) {
   switch (type) {
     case TSDB_DATA_TYPE_TINYINT: {
         int8_t* plist = (int8_t*)pCol->pData;
-        for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
+        for (int32_t i = start; i < numOfRows + start; ++i) {
           if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
             continue;
           }
@@ -749,9 +739,9 @@ int32_t percentileFunction(SqlFunctionCtx *pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
-// TODO set the correct parameter.
 void percentileFinalize(SqlFunctionCtx* pCtx) {
-  double v = 50;//pCtx->param[0].nType == TSDB_DATA_TYPE_INT ? pCtx->param[0].i64 : pCtx->param[0].dKey;
+  SVariant* pVal = &pCtx->param[1].param;
+  double v = pVal->nType == TSDB_DATA_TYPE_INT ? pVal->i : pVal->d;
 
   SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
   SPercentileInfo* ppInfo = (SPercentileInfo *) GET_ROWCELL_INTERBUF(pResInfo);
@@ -1173,3 +1163,130 @@ int32_t diffFunction(SqlFunctionCtx *pCtx) {
   }
 }
 
+typedef struct STopBotResItem {
+  SVariant v;
+  uint64_t uid;        // it is a table uid, used to extract tag data during building of the final result for the tag data
+  struct {
+   int32_t pageId;
+   int32_t offset;
+  } tuplePos;          // tuple data of this chosen row
+} STopBotResItem;
+
+typedef struct STopBotRes {
+  int32_t   num;
+  STopBotResItem *pItems;
+} STopBotRes;
+
+bool getTopBotFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
+  SColumnNode* pColNode = (SColumnNode*) nodesListGetNode(pFunc->pParameterList, 0);
+  int32_t bytes = pColNode->node.resType.bytes;
+  SValueNode* pkNode = (SValueNode*) nodesListGetNode(pFunc->pParameterList, 1);
+
+  pEnv->calcMemSize = sizeof(STopBotRes) + pkNode->datum.i * bytes;
+  return true;
+}
+
+static STopBotRes *getTopBotOutputInfo(SqlFunctionCtx *pCtx) {
+  SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
+  STopBotRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
+  pRes->pItems = (STopBotResItem*)((char*) pRes + sizeof(STopBotRes));
+
+  return pRes;
+}
+
+static void doAddIntoResult(STopBotRes *pRes, int32_t maxSize, void *pData, uint16_t type, uint64_t uid);
+
+int32_t topFunction(SqlFunctionCtx *pCtx) {
+  int32_t numOfElems = 0;
+
+  STopBotRes *pRes = getTopBotOutputInfo(pCtx);
+  assert(pRes->num >= 0);
+
+//  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotRes) + POINTER_BYTES * pCtx->param[0].i)) {
+//    buildTopBotStruct(pRes, pCtx);
+//  }
+
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnInfoData* pCol = pInput->pData[0];
+
+  int32_t type = pInput->pData[0]->info.type;
+
+  int32_t start = pInput->startRowIndex;
+  int32_t numOfRows = pInput->numOfRows;
+
+  for (int32_t i = start; i < numOfRows + start; ++i) {
+    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+      continue;
+    }
+    numOfElems++;
+
+    char* data = colDataGetData(pCol, i);
+    doAddIntoResult(pRes, pCtx->param[1].param.i, data, type, pInput->uid);
+  }
+
+  // treat the result as only one result
+  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t topBotResComparFn(const void *p1, const void *p2, const void *param) {
+  uint16_t type = *(uint16_t *) param;
+
+  STopBotResItem  *val1 = (STopBotResItem *) p1;
+  STopBotResItem  *val2 = (STopBotResItem *) p2;
+
+  if (IS_SIGNED_NUMERIC_TYPE(type)) {
+    if (val1->v.i == val2->v.i) {
+      return 0;
+    }
+
+    return (val1->v.i > val2->v.i) ? 1 : -1;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    if (val1->v.u == val2->v.u) {
+      return 0;
+    }
+
+    return (val1->v.u > val2->v.u) ? 1 : -1;
+  }
+
+  if (val1->v.d == val2->v.d) {
+    return 0;
+  }
+
+  return (val1->v.d > val2->v.d) ? 1 : -1;
+}
+
+void doAddIntoResult(STopBotRes *pRes, int32_t maxSize, void *pData, uint16_t type, uint64_t uid) {
+  SVariant val = {0};
+  taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type);
+
+  STopBotResItem *pItems = pRes->pItems;
+  assert(pItems != NULL);
+
+  // not full yet
+  if (pRes->num < maxSize) {
+    STopBotResItem* pItem = &pItems[pRes->num];
+    pItem->v   = val;
+    pItem->uid = uid;
+    pItem->tuplePos.pageId = -1;  // todo set the corresponding tuple data in the disk-based buffer
+
+    pRes->num++;
+    taosheapsort((void *) pItem, sizeof(STopBotResItem), pRes->num, (const void *) &type, topBotResComparFn, false);
+  } else { // replace the minimum value in the result
+    if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) ||
+        (IS_FLOAT_TYPE(type) && val.d > pItems[0].v.d)) {
+      STopBotResItem* pItem = &pItems[pRes->num];
+      pItem->v   = val;
+      pItem->uid = uid;
+      pItem->tuplePos.pageId = -1;  // todo set the corresponding tuple data in the disk-based buffer
+
+      taosheapadjust((void *) pItem, sizeof(STopBotResItem), 0, pRes->num - 1, (const void *) &type, topBotResComparFn, NULL, false);
+    }
+  }
+}
+
+void topBotFinalize(SqlFunctionCtx* pCtx) {
+  functionFinalize(pCtx);
+
+}
\ No newline at end of file
diff --git a/source/libs/function/src/taggfunction.c b/source/libs/function/src/taggfunction.c
index 56ee9bc9ae..c26342bfa8 100644
--- a/source/libs/function/src/taggfunction.c
+++ b/source/libs/function/src/taggfunction.c
@@ -765,9 +765,9 @@ static int32_t firstFuncRequired(SqlFunctionCtx *pCtx, STimeWindow* w, int32_t c
 }
 
 static int32_t lastFuncRequired(SqlFunctionCtx *pCtx, STimeWindow* w, int32_t colId) {
-  if (pCtx->order != pCtx->param[0].i) {
-    return BLK_DATA_NOT_LOAD;
-  }
+//  if (pCtx->order != pCtx->param[0].param.i) {
+//    return BLK_DATA_NOT_LOAD;
+//  }
   
   if (GET_RES_INFO(pCtx) == NULL || GET_RES_INFO(pCtx)->numOfRes <= 0) {
     return BLK_DATA_DATA_LOAD;
@@ -797,9 +797,9 @@ static int32_t firstDistFuncRequired(SqlFunctionCtx *pCtx, STimeWindow* w, int32
 }
 
 static int32_t lastDistFuncRequired(SqlFunctionCtx *pCtx, STimeWindow* w, int32_t colId) {
-  if (pCtx->order != pCtx->param[0].i) {
-    return BLK_DATA_NOT_LOAD;
-  }
+//  if (pCtx->order != pCtx->param[0].param.i) {
+//    return BLK_DATA_NOT_LOAD;
+//  }
 
   // not initialized yet, it is the first block, load it.
   if (pCtx->pOutput == NULL) {
@@ -1261,128 +1261,6 @@ int32_t tsCompare(const void* p1, const void* p2) {
   }
 }
 
-static void stddev_dst_function(SqlFunctionCtx *pCtx) {
-  SStddevdstInfo *pStd = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
-
-  // the second stage to calculate standard deviation
-  double *retVal = &pStd->res;
-
-  // all data are null, no need to proceed
-  SArray* resList = (SArray*) pCtx->param[0].pz;
-  if (resList == NULL) {
-    return;
-  }
-
-  // find the correct group average results according to the tag value
-  int32_t len = (int32_t) taosArrayGetSize(resList);
-  assert(len > 0);
-
-  double avg = 0;
-  if (len == 1) {
-    SResPair* p = taosArrayGet(resList, 0);
-    avg = p->avg;
-  } else {  // todo opt performance by using iterator since the timestamp lsit is matched with the output result
-    SResPair* p = bsearch(&pCtx->startTs, resList->pData, len, sizeof(SResPair), tsCompare);
-    if (p == NULL) {
-      return;
-    }
-
-    avg = p->avg;
-  }
-
-  void *pData = GET_INPUT_DATA_LIST(pCtx);
-  int32_t num = 0;
-
-  switch (pCtx->inputType) {
-    case TSDB_DATA_TYPE_INT: {
-      for (int32_t i = 0; i < pCtx->size; ++i) {
-        if (pCtx->hasNull && isNull((const char*) (&((int32_t *)pData)[i]), pCtx->inputType)) {
-          continue;
-        }
-        num += 1;
-        *retVal += TPOW2(((int32_t *)pData)[i] - avg);
-      }
-      break;
-    }
-    case TSDB_DATA_TYPE_FLOAT: {
-      LOOP_STDDEV_IMPL(float, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_DOUBLE: {
-      LOOP_STDDEV_IMPL(double, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_TINYINT: {
-      LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_UTINYINT: {
-      LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_SMALLINT: {
-      LOOP_STDDEV_IMPL(int16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_USMALLINT: {
-      LOOP_STDDEV_IMPL(uint16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_UINT: {
-      LOOP_STDDEV_IMPL(uint32_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_BIGINT: {
-      LOOP_STDDEV_IMPL(int64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    case TSDB_DATA_TYPE_UBIGINT: {
-      LOOP_STDDEV_IMPL(uint64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
-      break;
-    }
-    default:
-      assert(0);
-//      qError("stddev function not support data type:%d", pCtx->inputType);
-  }
-
-  pStd->num += num;
-  SET_VAL(pCtx, num, 1);
-
-  // copy to the final output buffer for super table
-  memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)), sizeof(SAvgInfo));
-}
-
-static void stddev_dst_merge(SqlFunctionCtx *pCtx) {
-  SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
-  SStddevdstInfo* pRes = GET_ROWCELL_INTERBUF(pResInfo);
-
-  char   *input = GET_INPUT_DATA_LIST(pCtx);
-
-  for (int32_t i = 0; i < pCtx->size; ++i, input += pCtx->inputBytes) {
-    SStddevdstInfo *pInput = (SStddevdstInfo *)input;
-    if (pInput->num == 0) {  // current input is null
-      continue;
-    }
-
-    pRes->num += pInput->num;
-    pRes->res += pInput->res;
-  }
-}
-
-static void stddev_dst_finalizer(SqlFunctionCtx *pCtx) {
-  SStddevdstInfo *pStd = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
-
-  if (pStd->num <= 0) {
-    setNull(pCtx->pOutput, pCtx->resDataInfo.type, pCtx->resDataInfo.bytes);
-  } else {
-    double *retValue = (double *)pCtx->pOutput;
-    SET_DOUBLE_VAL(retValue, sqrt(pStd->res / pStd->num));
-    SET_VAL(pCtx, 1, 1);
-  }
-
-  doFinalizer(pCtx);
-}
-
 //////////////////////////////////////////////////////////////////////////////////////
 static bool first_last_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo) {
   if (!function_setup(pCtx, pResInfo)) {
@@ -1390,8 +1268,8 @@ static bool first_last_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInfo*
   }
   
   // used to keep the timestamp for comparison
-  pCtx->param[1].nType = 0;
-  pCtx->param[1].i = 0;
+//  pCtx->param[1].param.nType = 0;
+//  pCtx->param[1].param.i = 0;
   
   return true;
 }
@@ -1487,13 +1365,13 @@ static void first_dist_func_merge(SqlFunctionCtx *pCtx) {
   }
   
   // The param[1] is used to keep the initial value of max ts value
-  if (pCtx->param[1].nType != pCtx->resDataInfo.type || pCtx->param[1].i > pInput->ts) {
-    memcpy(pCtx->pOutput, pData, pCtx->resDataInfo.bytes);
-    pCtx->param[1].i = pInput->ts;
-    pCtx->param[1].nType = pCtx->resDataInfo.type;
-    
-//    DO_UPDATE_TAG_COLUMNS(pCtx, pInput->ts);
-  }
+//  if (pCtx->param[1].param.nType != pCtx->resDataInfo.type || pCtx->param[1].param.i > pInput->ts) {
+//    memcpy(pCtx->pOutput, pData, pCtx->resDataInfo.bytes);
+//    pCtx->param[1].param.i = pInput->ts;
+//    pCtx->param[1].param.nType = pCtx->resDataInfo.type;
+//
+////    DO_UPDATE_TAG_COLUMNS(pCtx, pInput->ts);
+//  }
   
   SET_VAL(pCtx, 1, 1);
 //  GET_RES_INFO(pCtx)->hasResult = DATA_SET_FLAG;
@@ -1508,9 +1386,9 @@ static void first_dist_func_merge(SqlFunctionCtx *pCtx) {
  *    least one data in this block that is not null.(TODO opt for this case)
  */
 static void last_function(SqlFunctionCtx *pCtx) {
-  if (pCtx->order != pCtx->param[0].i) {
-    return;
-  }
+//  if (pCtx->order != pCtx->param[0].param.i) {
+//    return;
+//  }
 
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
 
@@ -1582,9 +1460,9 @@ static void last_dist_function(SqlFunctionCtx *pCtx) {
    * 1. for scan data is not the required order
    * 2. for data blocks that are not loaded, no need to check data
    */
-  if (pCtx->order != pCtx->param[0].i) {
-    return;
-  }
+//  if (pCtx->order != pCtx->param[0].param.i) {
+//    return;
+//  }
 
   int32_t notNullElems = 0;
   for (int32_t i = pCtx->size - 1; i >= 0; --i) {
@@ -1624,10 +1502,10 @@ static void last_dist_func_merge(SqlFunctionCtx *pCtx) {
    * param[1] used to keep the corresponding timestamp to decide if current result is
    * the true last result
    */
-  if (pCtx->param[1].nType != pCtx->resDataInfo.type || pCtx->param[1].i < pInput->ts) {
+  if (pCtx->param[1].param.nType != pCtx->resDataInfo.type || pCtx->param[1].param.i < pInput->ts) {
     memcpy(pCtx->pOutput, pData, pCtx->resDataInfo.bytes);
-    pCtx->param[1].i = pInput->ts;
-    pCtx->param[1].nType = pCtx->resDataInfo.type;
+    pCtx->param[1].param.i = pInput->ts;
+    pCtx->param[1].param.nType = pCtx->resDataInfo.type;
     
 //    DO_UPDATE_TAG_COLUMNS(pCtx, pInput->ts);
   }
@@ -1955,11 +1833,11 @@ static STopBotInfo *getTopBotOutputInfo(SqlFunctionCtx *pCtx) {
 static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SqlFunctionCtx *pCtx) {
   char *tmp = (char *)pTopBotInfo + sizeof(STopBotInfo);
   pTopBotInfo->res = (tValuePair**) tmp;
-  tmp += POINTER_BYTES * pCtx->param[0].i;
+//  tmp += POINTER_BYTES * pCtx->param[0].param.i;
 
 //  size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
 
-//  for (int32_t i = 0; i < pCtx->param[0].i; ++i) {
+//  for (int32_t i = 0; i < pCtx->param[0].param.i; ++i) {
 //    pTopBotInfo->res[i] = (tValuePair*) tmp;
 //    pTopBotInfo->res[i]->pTags = tmp + sizeof(tValuePair);
 //    tmp += size;
@@ -1975,13 +1853,13 @@ bool topbot_datablock_filter(SqlFunctionCtx *pCtx, const char *minval, const cha
   STopBotInfo *pTopBotInfo = getTopBotOutputInfo(pCtx);
   
   // required number of results are not reached, continue load data block
-  if (pTopBotInfo->num < pCtx->param[0].i) {
-    return true;
-  }
+//  if (pTopBotInfo->num < pCtx->param[0].param.i) {
+//    return true;
+//  }
   
-  if ((void *)pTopBotInfo->res[0] != (void *)((char *)pTopBotInfo + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i)) {
-    buildTopBotStruct(pTopBotInfo, pCtx);
-  }
+//  if ((void *)pTopBotInfo->res[0] != (void *)((char *)pTopBotInfo + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].param.i)) {
+//    buildTopBotStruct(pTopBotInfo, pCtx);
+//  }
 
   tValuePair **pRes = (tValuePair**) pTopBotInfo->res;
   
@@ -2038,9 +1916,9 @@ static void top_function(SqlFunctionCtx *pCtx) {
   STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
   assert(pRes->num >= 0);
 
-  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i)) {
-    buildTopBotStruct(pRes, pCtx);
-  }
+//  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].param.i)) {
+//    buildTopBotStruct(pRes, pCtx);
+//  }
   
   for (int32_t i = 0; i < pCtx->size; ++i) {
     char *data = GET_INPUT_DATA(pCtx, i);
@@ -2052,7 +1930,7 @@ static void top_function(SqlFunctionCtx *pCtx) {
 
     // NOTE: Set the default timestamp if it is missing [todo refactor]
     TSKEY ts = (pCtx->ptsList != NULL)? GET_TS_DATA(pCtx, i):0;
-//    do_top_function_add(pRes, (int32_t)pCtx->param[0].i, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
+//    do_top_function_add(pRes, (int32_t)pCtx->param[0].param.i, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
   }
   
   if (!pCtx->hasNull) {
@@ -2079,7 +1957,7 @@ static void top_func_merge(SqlFunctionCtx *pCtx) {
   // the intermediate result is binary, we only use the output data type
   for (int32_t i = 0; i < pInput->num; ++i) {
     int16_t type = (pCtx->resDataInfo.type == TSDB_DATA_TYPE_FLOAT)? TSDB_DATA_TYPE_DOUBLE:pCtx->resDataInfo.type;
-//    do_top_function_add(pOutput, (int32_t)pCtx->param[0].i, &pInput->res[i]->v.i, pInput->res[i]->timestamp,
+//    do_top_function_add(pOutput, (int32_t)pCtx->param[0].param.i, &pInput->res[i]->v.i, pInput->res[i]->timestamp,
 //                        type, &pCtx->tagInfo, pInput->res[i]->pTags, pCtx->currentStage);
   }
   
@@ -2096,9 +1974,9 @@ static void bottom_function(SqlFunctionCtx *pCtx) {
   
   STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
   
-  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i)) {
-    buildTopBotStruct(pRes, pCtx);
-  }
+//  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].param.i)) {
+//    buildTopBotStruct(pRes, pCtx);
+//  }
 
   for (int32_t i = 0; i < pCtx->size; ++i) {
     char *data = GET_INPUT_DATA(pCtx, i);
@@ -2109,7 +1987,7 @@ static void bottom_function(SqlFunctionCtx *pCtx) {
     notNullElems++;
     // NOTE: Set the default timestamp if it is missing [todo refactor]
     TSKEY ts = (pCtx->ptsList != NULL)? GET_TS_DATA(pCtx, i):0;
-//    do_bottom_function_add(pRes, (int32_t)pCtx->param[0].i, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
+//    do_bottom_function_add(pRes, (int32_t)pCtx->param[0].param.i, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
   }
   
   if (!pCtx->hasNull) {
@@ -2136,7 +2014,7 @@ static void bottom_func_merge(SqlFunctionCtx *pCtx) {
   // the intermediate result is binary, we only use the output data type
   for (int32_t i = 0; i < pInput->num; ++i) {
     int16_t type = (pCtx->resDataInfo.type == TSDB_DATA_TYPE_FLOAT) ? TSDB_DATA_TYPE_DOUBLE : pCtx->resDataInfo.type;
-//    do_bottom_function_add(pOutput, (int32_t)pCtx->param[0].i, &pInput->res[i]->v.i, pInput->res[i]->timestamp, type,
+//    do_bottom_function_add(pOutput, (int32_t)pCtx->param[0].param.i, &pInput->res[i]->v.i, pInput->res[i]->timestamp, type,
 //                           &pCtx->tagInfo, pInput->res[i]->pTags, pCtx->currentStage);
   }
 
@@ -2162,11 +2040,11 @@ static void top_bottom_func_finalizer(SqlFunctionCtx *pCtx) {
   tValuePair **tvp = pRes->res;
   
   // user specify the order of output by sort the result according to timestamp
-  if (pCtx->param[1].i == PRIMARYKEY_TIMESTAMP_COL_ID) {
-    __compar_fn_t comparator = (pCtx->param[2].i == TSDB_ORDER_ASC) ? resAscComparFn : resDescComparFn;
+  if (pCtx->param[1].param.i == PRIMARYKEY_TIMESTAMP_COL_ID) {
+    __compar_fn_t comparator = (pCtx->param[2].param.i == TSDB_ORDER_ASC) ? resAscComparFn : resDescComparFn;
     qsort(tvp, (size_t)pResInfo->numOfRes, POINTER_BYTES, comparator);
-  } else /*if (pCtx->param[1].i > PRIMARYKEY_TIMESTAMP_COL_ID)*/ {
-    __compar_fn_t comparator = (pCtx->param[2].i == TSDB_ORDER_ASC) ? resDataAscComparFn : resDataDescComparFn;
+  } else /*if (pCtx->param[1].param.i > PRIMARYKEY_TIMESTAMP_COL_ID)*/ {
+    __compar_fn_t comparator = (pCtx->param[2].param.i == TSDB_ORDER_ASC) ? resDataAscComparFn : resDataDescComparFn;
     qsort(tvp, (size_t)pResInfo->numOfRes, POINTER_BYTES, comparator);
   }
   
@@ -2277,7 +2155,7 @@ static void percentile_function(SqlFunctionCtx *pCtx) {
 }
 
 static void percentile_finalizer(SqlFunctionCtx *pCtx) {
-  double v = pCtx->param[0].nType == TSDB_DATA_TYPE_INT ? pCtx->param[0].i : pCtx->param[0].d;
+//  double v = pCtx->param[0].param.nType == TSDB_DATA_TYPE_INT ? pCtx->param[0].param.i : pCtx->param[0].param.d;
   
   SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
   SPercentileInfo* ppInfo = (SPercentileInfo *) GET_ROWCELL_INTERBUF(pResInfo);
@@ -2287,7 +2165,7 @@ static void percentile_finalizer(SqlFunctionCtx *pCtx) {
     assert(ppInfo->numOfElems == 0);
     setNull(pCtx->pOutput, pCtx->resDataInfo.type, pCtx->resDataInfo.bytes);
   } else {
-    SET_DOUBLE_VAL((double *)pCtx->pOutput, getPercentile(pMemBucket, v));
+//    SET_DOUBLE_VAL((double *)pCtx->pOutput, getPercentile(pMemBucket, v));
   }
   
   tMemBucketDestroy(pMemBucket);
@@ -2389,7 +2267,7 @@ static void apercentile_func_merge(SqlFunctionCtx *pCtx) {
 }
 
 static void apercentile_finalizer(SqlFunctionCtx *pCtx) {
-  double v = (pCtx->param[0].nType == TSDB_DATA_TYPE_INT) ? pCtx->param[0].i : pCtx->param[0].d;
+  double v = (pCtx->param[0].param.nType == TSDB_DATA_TYPE_INT) ? pCtx->param[0].param.i : pCtx->param[0].param.d;
   
   SResultRowEntryInfo *     pResInfo = GET_RES_INFO(pCtx);
   SAPercentileInfo *pOutput = GET_ROWCELL_INTERBUF(pResInfo);
@@ -2432,7 +2310,7 @@ static bool leastsquares_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInf
   SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   // 2*3 matrix
-  pInfo->startVal = pCtx->param[0].d;
+//  pInfo->startVal = pCtx->param[0].param.d;
   return true;
 }
 
@@ -2478,54 +2356,54 @@ static void leastsquares_function(SqlFunctionCtx *pCtx) {
         param[0][2] += x * p[i];
         param[1][2] += p[i];
         
-        x += pCtx->param[1].d;
+        x += pCtx->param[1].param.d;
         numOfElem++;
       }
       break;
     }
     case TSDB_DATA_TYPE_BIGINT: {
       int64_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_DOUBLE: {
       double *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_FLOAT: {
       float *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     };
     case TSDB_DATA_TYPE_SMALLINT: {
       int16_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_TINYINT: {
       int8_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_UTINYINT: {
       uint8_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_USMALLINT: {
       uint16_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_UINT: {
       uint32_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
     case TSDB_DATA_TYPE_UBIGINT: {
       uint64_t *p = pData;
-      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].d);
+      LEASTSQR_CAL_LOOP(pCtx, param, x, p, pCtx->inputType, numOfElem, pCtx->param[1].param.d);
       break;
     }
   }
@@ -2584,16 +2462,16 @@ static void col_project_function(SqlFunctionCtx *pCtx) {
   }
 
   // only one row is required.
-  if (pCtx->param[0].i == 1) {
-    SET_VAL(pCtx, pCtx->size, 1);
-  } else {
-    INC_INIT_VAL(pCtx, pCtx->size);
-  }
+//  if (pCtx->param[0].param.i == 1) {
+//    SET_VAL(pCtx, pCtx->size, 1);
+//  } else {
+//    INC_INIT_VAL(pCtx, pCtx->size);
+//  }
 
   char *pData = GET_INPUT_DATA_LIST(pCtx);
   if (pCtx->order == TSDB_ORDER_ASC) {
-    int32_t numOfRows = (pCtx->param[0].i == 1)? 1:pCtx->size;
-    memcpy(pCtx->pOutput, pData, (size_t) numOfRows * pCtx->inputBytes);
+//    int32_t numOfRows = (pCtx->param[0].param.i == 1)? 1:pCtx->size;
+//    memcpy(pCtx->pOutput, pData, (size_t) numOfRows * pCtx->inputBytes);
   } else {
     for(int32_t i = 0; i < pCtx->size; ++i) {
       memcpy(pCtx->pOutput + (pCtx->size - 1 - i) * pCtx->inputBytes, pData + i * pCtx->inputBytes,
@@ -2658,7 +2536,7 @@ static bool diff_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResI
   }
   
   // diff function require the value is set to -1
-  pCtx->param[1].nType = INITIAL_VALUE_NOT_ASSIGNED;
+  pCtx->param[1].param.nType = INITIAL_VALUE_NOT_ASSIGNED;
   return false;
 }
 
@@ -2670,9 +2548,9 @@ static bool deriv_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pRes
   // diff function require the value is set to -1
   SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResultInfo);
 
-  pDerivInfo->ignoreNegative = pCtx->param[1].i;
+//  pDerivInfo->ignoreNegative = pCtx->param[1].param.i;
   pDerivInfo->prevTs   = -1;
-  pDerivInfo->tsWindow = pCtx->param[0].i;
+//  pDerivInfo->tsWindow = pCtx->param[0].param.i;
   pDerivInfo->valueSet = false;
   return false;
 }
@@ -2861,12 +2739,12 @@ static void deriv_function(SqlFunctionCtx *pCtx) {
 
 #define DIFF_IMPL(ctx, d, type)                                                              \
   do {                                                                                       \
-    if ((ctx)->param[1].nType == INITIAL_VALUE_NOT_ASSIGNED) {                               \
-      (ctx)->param[1].nType = (ctx)->inputType;                                              \
-      *(type *)&(ctx)->param[1].i = *(type *)(d);                                       \
+    if ((ctx)->param[1].param.nType == INITIAL_VALUE_NOT_ASSIGNED) {                               \
+      (ctx)->param[1].param.nType = (ctx)->inputType;                                              \
+      *(type *)&(ctx)->param[1].param.i = *(type *)(d);                                       \
     } else {                                                                                 \
-      *(type *)(ctx)->pOutput = *(type *)(d) - (*(type *)(&(ctx)->param[1].i));      \
-      *(type *)(&(ctx)->param[1].i) = *(type *)(d);                                     \
+      *(type *)(ctx)->pOutput = *(type *)(d) - (*(type *)(&(ctx)->param[1].param.i));      \
+      *(type *)(&(ctx)->param[1].param.i) = *(type *)(d);                                     \
       *(int64_t *)(ctx)->pTsOutput = GET_TS_DATA(ctx, index);                             \
     }                                                                                        \
   } while (0);
@@ -2874,7 +2752,7 @@ static void deriv_function(SqlFunctionCtx *pCtx) {
 // TODO difference in date column
 static void diff_function(SqlFunctionCtx *pCtx) {
   void *data = GET_INPUT_DATA_LIST(pCtx);
-  bool  isFirstBlock = (pCtx->param[1].nType == INITIAL_VALUE_NOT_ASSIGNED);
+  bool  isFirstBlock = (pCtx->param[1].param.nType == INITIAL_VALUE_NOT_ASSIGNED);
 
   int32_t notNullElems = 0;
 
@@ -2894,15 +2772,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          *pOutput = (int32_t)(pData[i] - pCtx->param[1].i);  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          *pOutput = (int32_t)(pData[i] - pCtx->param[1].param.i);  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].i = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.i = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -2916,15 +2794,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          *pOutput = pData[i] - pCtx->param[1].i;  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          *pOutput = pData[i] - pCtx->param[1].param.i;  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].i = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.i = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -2938,15 +2816,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          SET_DOUBLE_VAL(pOutput, pData[i] - pCtx->param[1].d);  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          SET_DOUBLE_VAL(pOutput, pData[i] - pCtx->param[1].param.d);  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].d = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.d = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -2960,15 +2838,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          *pOutput = (float)(pData[i] - pCtx->param[1].d);  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          *pOutput = (float)(pData[i] - pCtx->param[1].param.d);  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].d = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.d = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -2982,15 +2860,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          *pOutput = (int16_t)(pData[i] - pCtx->param[1].i);  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          *pOutput = (int16_t)(pData[i] - pCtx->param[1].param.i);  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].i = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.i = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -3005,15 +2883,15 @@ static void diff_function(SqlFunctionCtx *pCtx) {
           continue;
         }
 
-        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
-          *pOutput = (int8_t)(pData[i] - pCtx->param[1].i);  // direct previous may be null
+        if (pCtx->param[1].param.nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
+          *pOutput = (int8_t)(pData[i] - pCtx->param[1].param.i);  // direct previous may be null
           *pTimestamp = (tsList != NULL)? tsList[i]:0;
           pOutput    += 1;
           pTimestamp += 1;
         }
 
-        pCtx->param[1].i = pData[i];
-        pCtx->param[1].nType = pCtx->inputType;
+        pCtx->param[1].param.i = pData[i];
+        pCtx->param[1].param.nType = pCtx->inputType;
         notNullElems++;
       }
       break;
@@ -3024,7 +2902,7 @@ static void diff_function(SqlFunctionCtx *pCtx) {
   }
 
   // initial value is not set yet
-  if (pCtx->param[1].nType == INITIAL_VALUE_NOT_ASSIGNED || notNullElems <= 0) {
+  if (pCtx->param[1].param.nType == INITIAL_VALUE_NOT_ASSIGNED || notNullElems <= 0) {
     /*
      * 1. current block and blocks before are full of null
      * 2. current block may be null value
@@ -3091,8 +2969,8 @@ static bool spread_function_setup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pRe
   
   // this is the server-side setup function in client-side, the secondary merge do not need this procedure
   if (pCtx->currentStage == MERGE_STAGE) {
-    pCtx->param[0].d = DBL_MAX;
-    pCtx->param[3].d = -DBL_MAX;
+//    pCtx->param[0].param.d = DBL_MAX;
+//    pCtx->param[3].param.d = -DBL_MAX;
   } else {
     pInfo->min = DBL_MAX;
     pInfo->max = -DBL_MAX;
@@ -3192,13 +3070,13 @@ void spread_func_merge(SqlFunctionCtx *pCtx) {
     return;
   }
   
-  if (pCtx->param[0].d > pData->min) {
-    pCtx->param[0].d = pData->min;
-  }
+//  if (pCtx->param[0].param.d > pData->min) {
+//    pCtx->param[0].param.d = pData->min;
+//  }
   
-  if (pCtx->param[3].d < pData->max) {
-    pCtx->param[3].d = pData->max;
-  }
+//  if (pCtx->param[3].param.d < pData->max) {
+//    pCtx->param[3].param.d = pData->max;
+//  }
   
 //  GET_RES_INFO(pCtx)->hasResult = DATA_SET_FLAG;
 }
@@ -3218,7 +3096,7 @@ void spread_function_finalizer(SqlFunctionCtx *pCtx) {
 //      return;
 //    }
     
-    SET_DOUBLE_VAL((double *)pCtx->pOutput, pCtx->param[3].d - pCtx->param[0].d);
+//    SET_DOUBLE_VAL((double *)pCtx->pOutput, pCtx->param[3].param.d - pCtx->param[0].param.d);
   } else {
     assert(IS_NUMERIC_TYPE(pCtx->inputType) || (pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP));
     
@@ -3571,7 +3449,7 @@ void twa_function_finalizer(SqlFunctionCtx *pCtx) {
  */
 
 static void interp_function_impl(SqlFunctionCtx *pCtx) {
-  int32_t type = (int32_t) pCtx->param[2].i;
+  int32_t type = (int32_t) pCtx->param[2].param.i;
   if (type == TSDB_FILL_NONE) {
     return;
   }
@@ -3583,7 +3461,7 @@ static void interp_function_impl(SqlFunctionCtx *pCtx) {
   } else if (type == TSDB_FILL_NULL) {
     setNull(pCtx->pOutput, pCtx->resDataInfo.type, pCtx->resDataInfo.bytes);
   } else if (type == TSDB_FILL_SET_VALUE) {
-    taosVariantDump(&pCtx->param[1], pCtx->pOutput, pCtx->inputType, true);
+//    taosVariantDump(&pCtx->param[1], pCtx->pOutput, pCtx->inputType, true);
   } else {
     if (pCtx->start.key != INT64_MIN && ((ascQuery && pCtx->start.key <= pCtx->startTs && pCtx->end.key >= pCtx->startTs) || ((!ascQuery) && pCtx->start.key >= pCtx->startTs && pCtx->end.key <= pCtx->startTs))) {
       if (type == TSDB_FILL_PREV) {
@@ -3755,11 +3633,11 @@ static void ts_comp_function(SqlFunctionCtx *pCtx) {
   
   // primary ts must be existed, so no need to check its existance
   if (pCtx->order == TSDB_ORDER_ASC) {
-    tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i, &pCtx->tag, input, pCtx->size * TSDB_KEYSIZE);
+//    tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].param.i, &pCtx->tag, input, pCtx->size * TSDB_KEYSIZE);
   } else {
     for (int32_t i = pCtx->size - 1; i >= 0; --i) {
       char *d = GET_INPUT_DATA(pCtx, i);
-      tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i, &pCtx->tag, d, (int32_t)TSDB_KEYSIZE);
+//      tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].param.i, &pCtx->tag, d, (int32_t)TSDB_KEYSIZE);
     }
   }
   
@@ -3911,7 +3789,7 @@ static void rate_finalizer(SqlFunctionCtx *pCtx) {
     return;
   }
   
-  SET_DOUBLE_VAL((double*) pCtx->pOutput, do_calc_rate(pRateInfo, (double) TSDB_TICK_PER_SECOND(pCtx->param[0].i)));
+//  SET_DOUBLE_VAL((double*) pCtx->pOutput, do_calc_rate(pRateInfo, (double) TSDB_TICK_PER_SECOND(pCtx->param[0].param.i)));
 
   // cannot set the numOfIteratedElems again since it is set during previous iteration
   pResInfo->numOfRes  = 1;
@@ -4008,7 +3886,7 @@ static void blockInfo_func(SqlFunctionCtx* pCtx) {
 
   int32_t len = *(int32_t*) pCtx->pInput;
   blockDistInfoFromBinary((char*)pCtx->pInput + sizeof(int32_t), len, pDist);
-  pDist->rowSize = (uint16_t)pCtx->param[0].i;
+//  pDist->rowSize = (uint16_t)pCtx->param[0].param.i;
 
   memcpy(pCtx->pOutput, pCtx->pInput, sizeof(int32_t) + len);
 
@@ -4160,7 +4038,7 @@ void blockinfo_func_finalizer(SqlFunctionCtx* pCtx) {
   SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
   STableBlockDistInfo* pDist = (STableBlockDistInfo*) GET_ROWCELL_INTERBUF(pResInfo);
 
-  pDist->rowSize = (uint16_t)pCtx->param[0].i;
+//  pDist->rowSize = (uint16_t)pCtx->param[0].param.i;
   generateBlockDistResult(pDist, pCtx->pOutput);
 
   if (pDist->dataBlockInfos != NULL) {
@@ -4557,9 +4435,9 @@ SAggFunctionInfo aggFunc[35] = {{
                               FUNCTION_AVG,
                               FUNCSTATE_SO | FUNCSTATE_STABLE,
                               function_setup,
-                              stddev_dst_function,
-                              stddev_dst_finalizer,
-                              stddev_dst_merge,
+                              NULL,
+                                    NULL,
+                                    NULL,
                               dataBlockRequired,
                           },
                           {
diff --git a/source/libs/function/src/tudf.c b/source/libs/function/src/tudf.c
index ad74daddc6..e31a860e85 100644
--- a/source/libs/function/src/tudf.c
+++ b/source/libs/function/src/tudf.c
@@ -14,19 +14,15 @@
  */
 #include "uv.h"
 #include "os.h"
-#include "tlog.h"
 #include "tudf.h"
 #include "tudfInt.h"
 #include "tarray.h"
 #include "tdatablock.h"
 
-//TODO: when startup, set thread poll size. add it to cfg
-//TODO: test for udfd restart
-//TODO: udfd restart when exist or aborts
-//TODO: deal with uv task that has been started and then udfd core dumped
 //TODO: network error processing.
 //TODO: add unit test
 //TODO: include all global variable under context struct
+
 /* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
  * The QUEUE is copied from queue.h under libuv
  * */
@@ -125,12 +121,35 @@ enum {
   UV_TASK_DISCONNECT = 2
 };
 
+int64_t gUdfTaskSeqNum = 0;
+typedef struct SUdfdProxy {
+  int32_t dnodeId;
+  uv_barrier_t gUdfInitBarrier;
+
+  uv_loop_t gUdfdLoop;
+  uv_thread_t gUdfLoopThread;
+  uv_async_t gUdfLoopTaskAync;
+
+  uv_async_t gUdfLoopStopAsync;
+
+  uv_mutex_t gUdfTaskQueueMutex;
+  int8_t gUdfcState;
+  QUEUE gUdfTaskQueue;
+  QUEUE gUvProcTaskQueue;
+  //  int8_t gUdfcState = UDFC_STATE_INITAL;
+  //  QUEUE gUdfTaskQueue = {0};
+  //  QUEUE gUvProcTaskQueue = {0};
+} SUdfdProxy;
+
+
 typedef struct SUdfUvSession {
+  SUdfdProxy *udfc;
   int64_t severHandle;
   uv_pipe_t *udfSvcPipe;
 } SUdfUvSession;
 
 typedef struct SClientUvTaskNode {
+  SUdfdProxy *udfc;
   int8_t type;
   int errCode;
 
@@ -169,7 +188,6 @@ typedef struct SClientUdfTask {
     } _teardown;
   };
 
-
 } SClientUdfTask;
 
 typedef struct SClientConnBuf {
@@ -185,34 +203,13 @@ typedef struct SClientUvConn {
   SClientConnBuf readBuf;
 } SClientUvConn;
 
-uv_process_t gUdfdProcess;
-
-uv_barrier_t gUdfInitBarrier;
-
-uv_loop_t gUdfdLoop;
-uv_thread_t gUdfLoopThread;
-uv_async_t gUdfLoopTaskAync;
-
-uv_async_t gUdfLoopStopAsync;
-
-uv_mutex_t gUdfTaskQueueMutex;
-int64_t gUdfTaskSeqNum = 0;
-
 enum {
   UDFC_STATE_INITAL = 0, // initial state
-  UDFC_STATE_STARTNG, // starting after createUdfdProxy
+  UDFC_STATE_STARTNG, // starting after udfcOpen
   UDFC_STATE_READY, // started and begin to receive quests
-  UDFC_STATE_RESTARTING, // udfd abnormal exit. cleaning up and restart.
-  UDFC_STATE_STOPPING, // stopping after destroyUdfdProxy
+  UDFC_STATE_STOPPING, // stopping after udfcClose
   UDFC_STATUS_FINAL, // stopped
 };
-int8_t gUdfcState = UDFC_STATE_INITAL;
-
-//double circular linked list
-
-QUEUE gUdfTaskQueue = {0};
-
-QUEUE gUvProcTaskQueue = {0};
 
 int32_t encodeUdfSetupRequest(void **buf, const SUdfSetupRequest *setup) {
   int32_t len = 0;
@@ -777,13 +774,14 @@ void onUdfClientConnect(uv_connect_t *connect, int status) {
 int32_t createUdfcUvTask(SClientUdfTask *task, int8_t uvTaskType, SClientUvTaskNode **pUvTask) {
   SClientUvTaskNode *uvTask = taosMemoryCalloc(1, sizeof(SClientUvTaskNode));
   uvTask->type = uvTaskType;
+  uvTask->udfc = task->session->udfc;
 
   if (uvTaskType == UV_TASK_CONNECT) {
   } else if (uvTaskType == UV_TASK_REQ_RSP) {
     uvTask->pipe = task->session->udfSvcPipe;
     SUdfRequest request;
     request.type = task->type;
-    request.seqNum = gUdfTaskSeqNum++;
+    request.seqNum =   atomic_fetch_add_64(&gUdfTaskSeqNum, 1);
 
     if (task->type == UDF_TASK_SETUP) {
       request.setup = task->_setup.req;
@@ -815,11 +813,11 @@ int32_t createUdfcUvTask(SClientUdfTask *task, int8_t uvTaskType, SClientUvTaskN
 
 int32_t queueUvUdfTask(SClientUvTaskNode *uvTask) {
   debugPrint("%s, %d", "queue uv task", uvTask->type);
-
-  uv_mutex_lock(&gUdfTaskQueueMutex);
-  QUEUE_INSERT_TAIL(&gUdfTaskQueue, &uvTask->recvTaskQueue);
-  uv_mutex_unlock(&gUdfTaskQueueMutex);
-  uv_async_send(&gUdfLoopTaskAync);
+  SUdfdProxy *udfc = uvTask->udfc;
+  uv_mutex_lock(&udfc->gUdfTaskQueueMutex);
+  QUEUE_INSERT_TAIL(&udfc->gUdfTaskQueue, &uvTask->recvTaskQueue);
+  uv_mutex_unlock(&udfc->gUdfTaskQueueMutex);
+  uv_async_send(&udfc->gUdfLoopTaskAync);
 
   uv_sem_wait(&uvTask->taskSem);
   uv_sem_destroy(&uvTask->taskSem);
@@ -832,7 +830,7 @@ int32_t startUvUdfTask(SClientUvTaskNode *uvTask) {
   switch (uvTask->type) {
     case UV_TASK_CONNECT: {
       uv_pipe_t *pipe = taosMemoryMalloc(sizeof(uv_pipe_t));
-      uv_pipe_init(&gUdfdLoop, pipe, 0);
+      uv_pipe_init(&uvTask->udfc->gUdfdLoop, pipe, 0);
       uvTask->pipe = pipe;
 
       SClientUvConn *conn = taosMemoryMalloc(sizeof(SClientUvConn));
@@ -873,142 +871,98 @@ int32_t startUvUdfTask(SClientUvTaskNode *uvTask) {
 }
 
 void udfClientAsyncCb(uv_async_t *async) {
+  SUdfdProxy *udfc = async->data;
   QUEUE wq;
 
-  uv_mutex_lock(&gUdfTaskQueueMutex);
-  QUEUE_MOVE(&gUdfTaskQueue, &wq);
-  uv_mutex_unlock(&gUdfTaskQueueMutex);
+  uv_mutex_lock(&udfc->gUdfTaskQueueMutex);
+  QUEUE_MOVE(&udfc->gUdfTaskQueue, &wq);
+  uv_mutex_unlock(&udfc->gUdfTaskQueueMutex);
 
   while (!QUEUE_EMPTY(&wq)) {
     QUEUE* h = QUEUE_HEAD(&wq);
     QUEUE_REMOVE(h);
     SClientUvTaskNode *task = QUEUE_DATA(h, SClientUvTaskNode, recvTaskQueue);
     startUvUdfTask(task);
-    QUEUE_INSERT_TAIL(&gUvProcTaskQueue, &task->procTaskQueue);
+    QUEUE_INSERT_TAIL(&udfc->gUvProcTaskQueue, &task->procTaskQueue);
   }
 
 }
 
-void cleanUpUvTasks() {
+void cleanUpUvTasks(SUdfdProxy *udfc) {
   QUEUE wq;
 
-  uv_mutex_lock(&gUdfTaskQueueMutex);
-  QUEUE_MOVE(&gUdfTaskQueue, &wq);
-  uv_mutex_unlock(&gUdfTaskQueueMutex);
+  uv_mutex_lock(&udfc->gUdfTaskQueueMutex);
+  QUEUE_MOVE(&udfc->gUdfTaskQueue, &wq);
+  uv_mutex_unlock(&udfc->gUdfTaskQueueMutex);
 
   while (!QUEUE_EMPTY(&wq)) {
     QUEUE* h = QUEUE_HEAD(&wq);
     QUEUE_REMOVE(h);
     SClientUvTaskNode *task = QUEUE_DATA(h, SClientUvTaskNode, recvTaskQueue);
-    if (gUdfcState == UDFC_STATE_STOPPING) {
+    if (udfc->gUdfcState == UDFC_STATE_STOPPING) {
       task->errCode = UDFC_CODE_STOPPING;
-    } else if (gUdfcState == UDFC_STATE_RESTARTING) {
-      task->errCode = UDFC_CODE_RESTARTING;
     }
     uv_sem_post(&task->taskSem);
   }
 
   // TODO: deal with tasks that are waiting result.
-  while (!QUEUE_EMPTY(&gUvProcTaskQueue)) {
-    QUEUE* h = QUEUE_HEAD(&gUvProcTaskQueue);
+  while (!QUEUE_EMPTY(&udfc->gUvProcTaskQueue)) {
+    QUEUE* h = QUEUE_HEAD(&udfc->gUvProcTaskQueue);
     QUEUE_REMOVE(h);
     SClientUvTaskNode *task = QUEUE_DATA(h, SClientUvTaskNode, procTaskQueue);
-    if (gUdfcState == UDFC_STATE_STOPPING) {
+    if (udfc->gUdfcState == UDFC_STATE_STOPPING) {
       task->errCode = UDFC_CODE_STOPPING;
-    } else if (gUdfcState == UDFC_STATE_RESTARTING) {
-      task->errCode = UDFC_CODE_RESTARTING;
     }
     uv_sem_post(&task->taskSem);
   }
 }
 
 void udfStopAsyncCb(uv_async_t *async) {
-  cleanUpUvTasks();
-  if (gUdfcState == UDFC_STATE_STOPPING) {
-    uv_stop(&gUdfdLoop);
+  SUdfdProxy *udfc = async->data;
+  cleanUpUvTasks(udfc);
+  if (udfc->gUdfcState == UDFC_STATE_STOPPING) {
+    uv_stop(&udfc->gUdfdLoop);
   }
 }
 
-int32_t udfcSpawnUdfd();
-
-void onUdfdExit(uv_process_t *req, int64_t exit_status, int term_signal) {
-  //TODO: pipe close will be first received
-  debugPrint("Process exited with status %" PRId64 ", signal %d", exit_status, term_signal);
-  uv_close((uv_handle_t *) req, NULL);
-  //TODO: restart the udfd process
-  if (gUdfcState == UDFC_STATE_STOPPING) {
-    if (term_signal != SIGINT) {
-      //TODO: log error
-    }
-  }
-  if (gUdfcState == UDFC_STATE_READY) {
-    gUdfcState = UDFC_STATE_RESTARTING;
-    //TODO: asynchronous without blocking. how to do it
-    //cleanUpUvTasks();
-    udfcSpawnUdfd();
-  }
-}
-
-int32_t udfcSpawnUdfd() {
-  //TODO: path
-  uv_process_options_t options = {0};
-  static char path[256] = {0};
-  size_t cwdSize;
-  uv_cwd(path, &cwdSize);
-  strcat(path, "/udfd");
-  char* args[2] = {path, NULL};
-  options.args = args;
-  options.file = path;
-  options.exit_cb = onUdfdExit;
-  options.stdio_count = 3;
-  uv_stdio_container_t child_stdio[3];
-  child_stdio[0].flags = UV_IGNORE;
-  child_stdio[1].flags = UV_INHERIT_FD;
-  child_stdio[1].data.fd = 1;
-  child_stdio[2].flags = UV_INHERIT_FD;
-  child_stdio[2].data.fd = 2;
-  options.stdio = child_stdio;
-  //TODO spawn error
-  int err = uv_spawn(&gUdfdLoop, &gUdfdProcess, &options);
-  if (err != 0) {
-    debugPrint("can not spawn udfd. path: %s, error: %s", path, uv_strerror(err));
-  }
-  return err;
-}
-
 void constructUdfService(void *argsThread) {
-  uv_loop_init(&gUdfdLoop);
+  SUdfdProxy *udfc = (SUdfdProxy*)argsThread;
+  uv_loop_init(&udfc->gUdfdLoop);
 
-  uv_async_init(&gUdfdLoop, &gUdfLoopTaskAync, udfClientAsyncCb);
-  uv_async_init(&gUdfdLoop, &gUdfLoopStopAsync, udfStopAsyncCb);
-  uv_mutex_init(&gUdfTaskQueueMutex);
-  QUEUE_INIT(&gUdfTaskQueue);
-  QUEUE_INIT(&gUvProcTaskQueue);
-  uv_barrier_wait(&gUdfInitBarrier);
+  uv_async_init(&udfc->gUdfdLoop, &udfc->gUdfLoopTaskAync, udfClientAsyncCb);
+  udfc->gUdfLoopTaskAync.data = udfc;
+  uv_async_init(&udfc->gUdfdLoop, &udfc->gUdfLoopStopAsync, udfStopAsyncCb);
+  udfc->gUdfLoopStopAsync.data = udfc;
+  uv_mutex_init(&udfc->gUdfTaskQueueMutex);
+  QUEUE_INIT(&udfc->gUdfTaskQueue);
+  QUEUE_INIT(&udfc->gUvProcTaskQueue);
+  uv_barrier_wait(&udfc->gUdfInitBarrier);
   //TODO return value of uv_run
-  uv_run(&gUdfdLoop, UV_RUN_DEFAULT);
-  uv_loop_close(&gUdfdLoop);
+  uv_run(&udfc->gUdfdLoop, UV_RUN_DEFAULT);
+  uv_loop_close(&udfc->gUdfdLoop);
 }
 
-
-int32_t createUdfdProxy(int32_t dnodeId) {
-  gUdfcState = UDFC_STATE_STARTNG;
-  uv_barrier_init(&gUdfInitBarrier, 2);
-  uv_thread_create(&gUdfLoopThread, constructUdfService, 0);
-  uv_barrier_wait(&gUdfInitBarrier);  gUdfcState = UDFC_STATE_READY;
+int32_t udfcOpen(int32_t dnodeId, UdfcHandle *udfc) {
+  SUdfdProxy *proxy = taosMemoryCalloc(1, sizeof(SUdfdProxy));
+  proxy->dnodeId = dnodeId;
+  proxy->gUdfcState = UDFC_STATE_STARTNG;
+  uv_barrier_init(&proxy->gUdfInitBarrier, 2);
+  uv_thread_create(&proxy->gUdfLoopThread, constructUdfService, proxy);
+  uv_barrier_wait(&proxy->gUdfInitBarrier);
+  proxy->gUdfcState = UDFC_STATE_READY;
+  *udfc = proxy;
   return 0;
 }
 
-int32_t destroyUdfdProxy(int32_t dnodeId) {
-  gUdfcState = UDFC_STATE_STOPPING;
-  uv_barrier_destroy(&gUdfInitBarrier);
-//  if (gUdfcState == UDFC_STATE_STOPPING) {
-//    uv_process_kill(&gUdfdProcess, SIGINT);
-//  }
-  uv_async_send(&gUdfLoopStopAsync);
-  uv_thread_join(&gUdfLoopThread);
-  uv_mutex_destroy(&gUdfTaskQueueMutex);
-  gUdfcState = UDFC_STATUS_FINAL;
+int32_t udfcClose(UdfcHandle udfcHandle) {
+  SUdfdProxy *udfc = udfcHandle;
+  udfc->gUdfcState = UDFC_STATE_STOPPING;
+  uv_async_send(&udfc->gUdfLoopStopAsync);
+  uv_thread_join(&udfc->gUdfLoopThread);
+  uv_mutex_destroy(&udfc->gUdfTaskQueueMutex);
+  uv_barrier_destroy(&udfc->gUdfInitBarrier);
+  udfc->gUdfcState = UDFC_STATUS_FINAL;
+  taosMemoryFree(udfc);
   return 0;
 }
 
@@ -1026,11 +980,12 @@ int32_t udfcRunUvTask(SClientUdfTask *task, int8_t uvTaskType) {
   return task->errCode;
 }
 
-int32_t setupUdf(char udfName[], SEpSet *epSet, UdfHandle *handle) {
+int32_t setupUdf(UdfcHandle udfc, char udfName[], SEpSet *epSet, UdfcFuncHandle *funcHandle) {
   debugPrint("%s", "client setup udf");
   SClientUdfTask *task = taosMemoryMalloc(sizeof(SClientUdfTask));
   task->errCode = 0;
   task->session = taosMemoryMalloc(sizeof(SUdfUvSession));
+  task->session->udfc = udfc;
   task->type = UDF_TASK_SETUP;
 
   SUdfSetupRequest *req = &task->_setup.req;
@@ -1046,13 +1001,13 @@ int32_t setupUdf(char udfName[], SEpSet *epSet, UdfHandle *handle) {
 
   SUdfSetupResponse *rsp = &task->_setup.rsp;
   task->session->severHandle = rsp->udfHandle;
-  *handle = task->session;
+  *funcHandle = task->session;
   int32_t err = task->errCode;
   taosMemoryFree(task);
   return err;
 }
 
-int32_t callUdf(UdfHandle handle, int8_t callType, SSDataBlock *input, SUdfInterBuf *state, SUdfInterBuf *state2,
+int32_t callUdf(UdfcFuncHandle handle, int8_t callType, SSDataBlock *input, SUdfInterBuf *state, SUdfInterBuf *state2,
                 SSDataBlock* output, SUdfInterBuf *newState) {
   debugPrint("%s", "client call udf");
 
@@ -1121,7 +1076,7 @@ int32_t callUdf(UdfHandle handle, int8_t callType, SSDataBlock *input, SUdfInter
 }
 
 //TODO: translate these calls to callUdf
-int32_t callUdfAggInit(UdfHandle handle, SUdfInterBuf *interBuf) {
+int32_t callUdfAggInit(UdfcFuncHandle handle, SUdfInterBuf *interBuf) {
   int8_t callType = TSDB_UDF_CALL_AGG_INIT;
 
   int32_t err = callUdf(handle, callType, NULL, NULL, NULL, NULL, interBuf);
@@ -1131,7 +1086,7 @@ int32_t callUdfAggInit(UdfHandle handle, SUdfInterBuf *interBuf) {
 
 // input: block, state
 // output: interbuf,
-int32_t callUdfAggProcess(UdfHandle handle, SSDataBlock *block, SUdfInterBuf *state, SUdfInterBuf *newState) {
+int32_t callUdfAggProcess(UdfcFuncHandle handle, SSDataBlock *block, SUdfInterBuf *state, SUdfInterBuf *newState) {
   int8_t callType = TSDB_UDF_CALL_AGG_PROC;
   int32_t err = callUdf(handle, callType, block, state, NULL, NULL, newState);
   return err;
@@ -1139,7 +1094,7 @@ int32_t callUdfAggProcess(UdfHandle handle, SSDataBlock *block, SUdfInterBuf *st
 
 // input: interbuf1, interbuf2
 // output: resultBuf
-int32_t callUdfAggMerge(UdfHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2, SUdfInterBuf *resultBuf) {
+int32_t callUdfAggMerge(UdfcFuncHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2, SUdfInterBuf *resultBuf) {
   int8_t callType = TSDB_UDF_CALL_AGG_MERGE;
   int32_t err = callUdf(handle, callType, NULL, interBuf1, interBuf2, NULL, resultBuf);
   return err;
@@ -1147,7 +1102,7 @@ int32_t callUdfAggMerge(UdfHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf
 
 // input: interBuf
 // output: resultData
-int32_t callUdfAggFinalize(UdfHandle handle, SUdfInterBuf *interBuf, SUdfInterBuf *resultData) {
+int32_t callUdfAggFinalize(UdfcFuncHandle handle, SUdfInterBuf *interBuf, SUdfInterBuf *resultData) {
   int8_t callType = TSDB_UDF_CALL_AGG_PROC;
   int32_t err = callUdf(handle, callType, NULL, interBuf, NULL, NULL, resultData);
   return err;
@@ -1155,13 +1110,13 @@ int32_t callUdfAggFinalize(UdfHandle handle, SUdfInterBuf *interBuf, SUdfInterBu
 
 // input: block
 // output: resultData
-int32_t callUdfScalaProcess(UdfHandle handle, SSDataBlock *block, SSDataBlock *resultData) {
+int32_t callUdfScalaProcess(UdfcFuncHandle handle, SSDataBlock *block, SSDataBlock *resultData) {
   int8_t callType = TSDB_UDF_CALL_SCALA_PROC;
   int32_t err = callUdf(handle, callType, block, NULL, NULL, resultData, NULL);
   return err;
 }
 
-int32_t teardownUdf(UdfHandle handle) {
+int32_t teardownUdf(UdfcFuncHandle handle) {
   debugPrint("%s", "client teardown udf");
 
   SClientUdfTask *task = taosMemoryMalloc(sizeof(SClientUdfTask));
diff --git a/source/libs/function/src/udfd.c b/source/libs/function/src/udfd.c
index 71434c695f..d6e7a43666 100644
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
@@ -27,7 +27,10 @@
 
 typedef struct SUdfdContext {
   uv_loop_t *loop;
+  uv_pipe_t ctrlPipe;
+  uv_signal_t intrSignal;
   char listenPipeName[UDF_LISTEN_PIPE_NAME_LEN];
+  uv_pipe_t listeningPipe;
   void      *clientRpc;
 
   uv_mutex_t udfsMutex;
@@ -76,9 +79,9 @@ typedef struct SUdf {
 
 // TODO: low priority: change name onxxx to xxxCb, and udfc or udfd as prefix
 // TODO: add private udf structure.
-typedef struct SUdfHandle {
+typedef struct SUdfcFuncHandle {
   SUdf *udf;
-} SUdfHandle;
+} SUdfcFuncHandle;
 
 int32_t udfdLoadUdf(char* udfName, SUdf* udf) {
     strcpy(udf->name, udfName);
@@ -143,7 +146,7 @@ void udfdProcessRequest(uv_work_t *req) {
         }
         uv_mutex_unlock(&udf->lock);
       }
-      SUdfHandle *handle = taosMemoryMalloc(sizeof(SUdfHandle));
+      SUdfcFuncHandle *handle = taosMemoryMalloc(sizeof(SUdfcFuncHandle));
       handle->udf = udf;
       // TODO: allocate private structure and call init function and set it to handle
       SUdfResponse rsp;
@@ -166,7 +169,7 @@ void udfdProcessRequest(uv_work_t *req) {
     case UDF_TASK_CALL: {
       SUdfCallRequest *call = &request.call;
       fnDebug("%"PRId64 "call request. call type %d, handle: %"PRIx64, request.seqNum, call->callType, call->udfHandle);
-      SUdfHandle      *handle = (SUdfHandle *)(call->udfHandle);
+      SUdfcFuncHandle      *handle = (SUdfcFuncHandle *)(call->udfHandle);
       SUdf            *udf = handle->udf;
 
       SUdfDataBlock input = {0};
@@ -204,7 +207,7 @@ void udfdProcessRequest(uv_work_t *req) {
     case UDF_TASK_TEARDOWN: {
       SUdfTeardownRequest *teardown = &request.teardown;
       fnInfo("teardown. %"PRId64"handle:%"PRIx64, request.seqNum, teardown->udfHandle)
-      SUdfHandle          *handle = (SUdfHandle *)(teardown->udfHandle);
+      SUdfcFuncHandle          *handle = (SUdfcFuncHandle *)(teardown->udfHandle);
       SUdf                *udf = handle->udf;
       bool unloadUdf = false;
       uv_mutex_lock(&global.udfsMutex);
@@ -380,10 +383,12 @@ void udfdOnNewConnection(uv_stream_t *server, int status) {
   }
 }
 
-void removeListeningPipe(int sig) {
+void udfdIntrSignalHandler(uv_signal_t *handle, int signum) {
+  fnInfo("udfd signal received: %d\n", signum);
   uv_fs_t req;
-  uv_fs_unlink(global.loop, &req, "udf.sock", NULL);
-  exit(0);
+  uv_fs_unlink(global.loop, &req, global.listenPipeName, NULL);
+  uv_signal_stop(handle);
+  uv_stop(global.loop);
 }
 
 void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) { return; }
@@ -492,37 +497,67 @@ static int32_t udfdInitLog() {
   return taosCreateLog(logName, 1, configDir, NULL, NULL, NULL, 0);
 }
 
+void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
+  buf->base = taosMemoryMalloc(suggested_size);
+  buf->len = suggested_size;
+}
+
+void udfdCtrlReadCb(uv_stream_t *q, ssize_t nread, const uv_buf_t *buf) {
+  if (nread < 0) {
+    fnError("udfd ctrl pipe read error. %s", uv_err_name(nread));
+    uv_close((uv_handle_t*)q, NULL);
+    uv_stop(global.loop);
+    return;
+  }
+  fnError("udfd ctrl pipe read %zu bytes", nread);
+  taosMemoryFree(buf->base);
+}
+
+static int32_t removeListeningPipe() {
+  uv_fs_t req;
+  int err = uv_fs_unlink(global.loop, &req, global.listenPipeName, NULL);
+  uv_fs_req_cleanup(&req);
+  return err;
+}
+
 static int32_t udfdUvInit() {
   uv_loop_t* loop = taosMemoryMalloc(sizeof(uv_loop_t));
   if (loop) {
     uv_loop_init(loop);
   }
   global.loop = loop;
+
+  uv_pipe_init(global.loop, &global.ctrlPipe, 1);
+  uv_pipe_open(&global.ctrlPipe, 0);
+  uv_read_start((uv_stream_t*)&global.ctrlPipe, udfdCtrlAllocBufCb, udfdCtrlReadCb);
+
   char dnodeId[8] = {0};
   size_t dnodeIdSize;
-  uv_os_getenv("DNODE_ID", dnodeId, &dnodeIdSize);
+  int32_t err = uv_os_getenv("DNODE_ID", dnodeId, &dnodeIdSize);
+  if (err != 0) {
+    dnodeId[0] = '1';
+  }
   char listenPipeName[32] = {0};
   snprintf(listenPipeName, sizeof(listenPipeName), "%s%s", UDF_LISTEN_PIPE_NAME_PREFIX, dnodeId);
   strcpy(global.listenPipeName, listenPipeName);
 
-  uv_fs_t req;
-  uv_fs_unlink(global.loop, &req, global.listenPipeName, NULL);
+  removeListeningPipe();
 
-  uv_pipe_t server;
-  uv_pipe_init(global.loop, &server, 0);
+  uv_pipe_init(global.loop, &global.listeningPipe, 0);
 
-  signal(SIGINT, removeListeningPipe);
+  uv_signal_init(global.loop, &global.intrSignal);
+  uv_signal_start(&global.intrSignal, udfdIntrSignalHandler, SIGINT);
 
   int r;
   fnInfo("bind to pipe %s", global.listenPipeName);
-  if ((r = uv_pipe_bind(&server, listenPipeName))) {
+  if ((r = uv_pipe_bind(&global.listeningPipe, listenPipeName))) {
     fnError("Bind error %s", uv_err_name(r));
-    removeListeningPipe(0);
+    removeListeningPipe();
     return -1;
   }
-  if ((r = uv_listen((uv_stream_t *)&server, 128, udfdOnNewConnection))) {
+  if ((r = uv_listen((uv_stream_t *)&global.listeningPipe, 128, udfdOnNewConnection))) {
     fnError("Listen error %s", uv_err_name(r));
-    removeListeningPipe(0);
+    removeListeningPipe();
     return -2;
   }
   return 0;
diff --git a/source/libs/function/test/runUdf.c b/source/libs/function/test/runUdf.c
index 41c7f65e0b..fb9c3c678a 100644
--- a/source/libs/function/test/runUdf.c
+++ b/source/libs/function/test/runUdf.c
@@ -8,7 +8,8 @@
 #include "tdatablock.h"
 
 int main(int argc, char *argv[]) {
-  createUdfdProxy(1);
+  UdfcHandle udfc;
+  udfcOpen(1, &udfc);
     uv_sleep(1000);
     char path[256] = {0};
     size_t cwdSize = 256;
@@ -20,9 +21,9 @@ int main(int argc, char *argv[]) {
     fprintf(stdout, "current working directory:%s\n", path);
     strcat(path, "/libudf1.so");
 
-    UdfHandle handle;
+    UdfcFuncHandle handle;
     SEpSet epSet;
-    setupUdf("udf1", &epSet, &handle);
+    setupUdf(udfc, "udf1", &epSet, &handle);
 
     SSDataBlock block = {0};
     SSDataBlock* pBlock = &block;
@@ -53,5 +54,5 @@ int main(int argc, char *argv[]) {
     }
     teardownUdf(handle);
 
-    destroyUdfdProxy(1);
+    udfcClose(udfc);
 }
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index e68a4389fe..9ff36c702f 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -837,6 +837,8 @@ query_expression(A) ::=
 query_expression_body(A) ::= query_primary(B).                                    { A = B; }
 query_expression_body(A) ::=
   query_expression_body(B) UNION ALL query_expression_body(D).                    { A = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, B, D); }
+query_expression_body(A) ::=
+  query_expression_body(B) UNION query_expression_body(D).                        { A = createSetOperator(pCxt, SET_OP_TYPE_UNION, B, D); }
 
 query_primary(A) ::= query_specification(B).                                      { A = B; }
 //query_primary(A) ::=
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 6f1531bd5f..804d856794 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -230,6 +230,21 @@ static int32_t initTranslateContext(SParseContext* pParseCxt, STranslateContext*
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t resetTranslateNamespace(STranslateContext* pCxt) {
+  if (NULL != pCxt->pNsLevel) {
+    size_t size = taosArrayGetSize(pCxt->pNsLevel);
+    for (size_t i = 0; i < size; ++i) {
+      taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i));
+    }
+    taosArrayDestroy(pCxt->pNsLevel);
+  }
+  pCxt->pNsLevel = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
+  if (NULL == pCxt->pNsLevel) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static void destroyTranslateContext(STranslateContext* pCxt) {
   if (NULL != pCxt->pNsLevel) {
     size_t size = taosArrayGetSize(pCxt->pNsLevel);
@@ -261,9 +276,11 @@ static bool belongTable(const char* currentDb, const SColumnNode* pCol, const ST
   return (0 == cmp);
 }
 
-static SNodeList* getProjectList(SNode* pNode) {
+static SNodeList* getProjectList(const SNode* pNode) {
   if (QUERY_NODE_SELECT_STMT == nodeType(pNode)) {
     return ((SSelectStmt*)pNode)->pProjectionList;
+  } else if (QUERY_NODE_SET_OPERATOR == nodeType(pNode)) {
+    return ((SSetOperator*)pNode)->pProjectionList;
   }
   return NULL;
 }
@@ -1357,13 +1374,77 @@ static int32_t translateSelect(STranslateContext* pCxt, SSelectStmt* pSelect) {
   return code;
 }
 
+static SNode* createSetOperProject(SNode* pNode) {
+  SColumnNode* pCol = nodesMakeNode(QUERY_NODE_COLUMN);
+  if (NULL == pCol) {
+    return NULL;
+  }
+  pCol->node.resType = ((SExprNode*)pNode)->resType;
+  strcpy(pCol->colName, ((SExprNode*)pNode)->aliasName);
+  strcpy(pCol->node.aliasName, pCol->colName);
+  return (SNode*)pCol;
+}
+
+static bool dataTypeEqual(const SDataType* l, const SDataType* r) {
+  return (l->type == r->type && l->bytes == l->bytes && l->precision == r->precision && l->scale == l->scale);
+}
+
+static int32_t createCastFunc(STranslateContext* pCxt, SNode* pExpr, SDataType dt, SNode** pCast) {
+  SFunctionNode* pFunc = nodesMakeNode(QUERY_NODE_FUNCTION);
+  if (NULL == pFunc) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  strcpy(pFunc->functionName, "cast");
+  pFunc->node.resType = dt;
+  if (TSDB_CODE_SUCCESS != nodesListMakeAppend(&pFunc->pParameterList, pExpr)) {
+    nodesDestroyNode(pFunc);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  if (DEAL_RES_ERROR == translateFunction(pCxt, pFunc)) {
+    nodesClearList(pFunc->pParameterList);
+    pFunc->pParameterList = NULL;
+    nodesDestroyNode(pFunc);
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_WRONG_VALUE_TYPE, ((SExprNode*)pExpr)->aliasName);
+  }
+  *pCast = (SNode*)pFunc;
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateSetOperatorImpl(STranslateContext* pCxt, SSetOperator* pSetOperator) {
-  // todo
+  SNodeList* pLeftProjections = getProjectList(pSetOperator->pLeft);
+  SNodeList* pRightProjections = getProjectList(pSetOperator->pRight);
+  if (LIST_LENGTH(pLeftProjections) != LIST_LENGTH(pRightProjections)) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INCORRECT_NUM_OF_COL);
+  }
+
+  SNode* pLeft = NULL;
+  SNode* pRight = NULL;
+  FORBOTH(pLeft, pLeftProjections, pRight, pRightProjections) {
+    SExprNode* pLeftExpr = (SExprNode*)pLeft;
+    SExprNode* pRightExpr = (SExprNode*)pRight;
+    if (!dataTypeEqual(&pLeftExpr->resType, &pRightExpr->resType)) {
+      SNode* pRightFunc = NULL;
+      int32_t code = createCastFunc(pCxt, pRight, pLeftExpr->resType, &pRightFunc);
+      if (TSDB_CODE_SUCCESS != code) {
+        return code;
+      }
+      REPLACE_LIST2_NODE(pRightFunc);
+      pRightExpr = (SExprNode*)pRightFunc;
+    }
+    strcpy(pRightExpr->aliasName, pLeftExpr->aliasName);
+    pRightExpr->aliasName[strlen(pLeftExpr->aliasName)] = '\0';
+    if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pSetOperator->pProjectionList, createSetOperProject(pLeft))) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
   return TSDB_CODE_SUCCESS;
 }
 
 static int32_t translateSetOperator(STranslateContext* pCxt, SSetOperator* pSetOperator) {
   int32_t code = translateQuery(pCxt, pSetOperator->pLeft);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = resetTranslateNamespace(pCxt);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = translateQuery(pCxt, pSetOperator->pRight);
   }
@@ -2799,8 +2880,8 @@ static int32_t translateSubquery(STranslateContext* pCxt, SNode* pNode) {
   return code;
 }
 
-static int32_t extractSelectResultSchema(const SSelectStmt* pSelect, int32_t* numOfCols, SSchema** pSchema) {
-  *numOfCols = LIST_LENGTH(pSelect->pProjectionList);
+static int32_t extractQueryResultSchema(const SNodeList* pProjections, int32_t* numOfCols, SSchema** pSchema) {
+  *numOfCols = LIST_LENGTH(pProjections);
   *pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema));
   if (NULL == (*pSchema)) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -2808,7 +2889,7 @@ static int32_t extractSelectResultSchema(const SSelectStmt* pSelect, int32_t* nu
 
   SNode*  pNode;
   int32_t index = 0;
-  FOREACH(pNode, pSelect->pProjectionList) {
+  FOREACH(pNode, pProjections) {
     SExprNode* pExpr = (SExprNode*)pNode;
     (*pSchema)[index].type = pExpr->resType.type;
     (*pSchema)[index].bytes = pExpr->resType.bytes;
@@ -2867,7 +2948,8 @@ int32_t extractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pS
 
   switch (nodeType(pRoot)) {
     case QUERY_NODE_SELECT_STMT:
-      return extractSelectResultSchema((SSelectStmt*)pRoot, numOfCols, pSchema);
+    case QUERY_NODE_SET_OPERATOR:
+      return extractQueryResultSchema(getProjectList(pRoot), numOfCols, pSchema);
     case QUERY_NODE_EXPLAIN_STMT:
       return extractExplainResultSchema(numOfCols, pSchema);
     case QUERY_NODE_DESCRIBE_STMT:
@@ -3490,6 +3572,7 @@ static int32_t rewriteQuery(STranslateContext* pCxt, SQuery* pQuery) {
 static int32_t setQuery(STranslateContext* pCxt, SQuery* pQuery) {
   switch (nodeType(pQuery->pRoot)) {
     case QUERY_NODE_SELECT_STMT:
+    case QUERY_NODE_SET_OPERATOR:
     case QUERY_NODE_EXPLAIN_STMT:
       pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
       pQuery->haveResultSet = true;
diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c
index 7f945eb70c..075caa868c 100644
--- a/source/libs/parser/src/parUtil.c
+++ b/source/libs/parser/src/parUtil.c
@@ -118,6 +118,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "sliding value can not less than 1% of interval value";
     case TSDB_CODE_PAR_ONLY_ONE_JSON_TAG:
       return "Only one tag if there is a json tag";
+    case TSDB_CODE_PAR_INCORRECT_NUM_OF_COL:
+      return "Query block has incorrect number of result columns";
     case TSDB_CODE_OUT_OF_MEMORY:
       return "Out of memory";
     default:
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index 48220dbef7..b38e4092e3 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -133,16 +133,16 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYNSTATE             572
-#define YYNRULE              436
+#define YYNRULE              437
 #define YYNTOKEN             222
 #define YY_MAX_SHIFT         571
-#define YY_MIN_SHIFTREDUCE   849
-#define YY_MAX_SHIFTREDUCE   1284
-#define YY_ERROR_ACTION      1285
-#define YY_ACCEPT_ACTION     1286
-#define YY_NO_ACTION         1287
-#define YY_MIN_REDUCE        1288
-#define YY_MAX_REDUCE        1723
+#define YY_MIN_SHIFTREDUCE   850
+#define YY_MAX_SHIFTREDUCE   1286
+#define YY_ERROR_ACTION      1287
+#define YY_ACCEPT_ACTION     1288
+#define YY_NO_ACTION         1289
+#define YY_MIN_REDUCE        1290
+#define YY_MAX_REDUCE        1726
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -211,368 +211,368 @@ typedef union {
 *********** Begin parsing tables **********************************************/
 #define YY_ACTTAB_COUNT (1960)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   269, 1591,  286,  472, 1575,  485,  281,  324,  469, 1503,
- /*    10 */  1286, 1399,   33,   31,   77, 1575,  123, 1561, 1300, 1561,
- /*    20 */   278,  382, 1105,   34,   32,   30,   29,   28, 1591, 1561,
- /*    30 */  1410, 1557, 1563, 1557, 1563,  469,  124,  249, 1103, 1591,
- /*    40 */  1367,   53,  437, 1557, 1564,  468,  469, 1387,  444, 1547,
- /*    50 */    12,   33,   31, 1227,   99,   53,  468, 1111,  484,  278,
- /*    60 */  1547, 1105, 1405,  294,  318,  448, 1575,  242, 1576,  471,
- /*    70 */  1578, 1579,  467,  104,  462,    1, 1406, 1103,   72, 1576,
- /*    80 */   471, 1578, 1579,  467,  361,  462,  484,  289, 1641,   12,
- /*    90 */  1591,  484,  250, 1637, 1494, 1496, 1111,  447,  568,   26,
- /*   100 */   204,  452, 1702, 1702, 1702,  440,  420,  468,  106,  102,
- /*   110 */  1104, 1547,  516,  485,    1,  136,  136,  136, 1327, 1700,
- /*   120 */  1700, 1700,  322,  446,  132, 1648, 1649,  444, 1653,   73,
- /*   130 */  1576,  471, 1578, 1579,  467,  519,  462,  568, 1410, 1641,
- /*   140 */   399,   36,  485,  271, 1637,  131,   36,   69, 1106, 1104,
- /*   150 */   421,  323,  104, 1126,  515,  514,  513,  200,  512, 1491,
- /*   160 */   127,  105, 1128,  427, 1668,  434,  145, 1410, 1402, 1109,
- /*   170 */  1110, 1451, 1154, 1155, 1156, 1157, 1158, 1159, 1160,  464,
- /*   180 */  1165, 1166, 1167, 1168, 1169, 1170, 1171, 1106,  102, 1702,
- /*   190 */  1459,   34,   32,   30,   29,   28,  268,    9,    8,  137,
- /*   200 */    68, 1457,  136,  133, 1648, 1649, 1700, 1653, 1109, 1110,
- /*   210 */    64, 1154, 1155, 1156, 1157, 1158, 1159, 1160,  464, 1165,
- /*   220 */  1166, 1167, 1168, 1169, 1170, 1171,   33,   31,  438,  251,
- /*   230 */   226,  439,  435, 1440,  278,  248, 1105, 1126, 1575,  398,
- /*   240 */   886,  392,  885, 1459,  340,  397,  453,  352,  101,  283,
- /*   250 */   393,  391, 1103,  394, 1457, 1141,  353,  317,  390,  316,
- /*   260 */   887,  137, 1591, 1189,   12,   33,   31,  387,  386,  469,
- /*   270 */   137, 1111, 1203,  278,   22, 1105, 1655,   55,  267,  468,
- /*   280 */  1251,  174,   24, 1547,   34,   32,   30,   29,   28,    1,
- /*   290 */  1655, 1103,   34,   32,   30,   29,   28,   30,   29,   28,
- /*   300 */  1652,   73, 1576,  471, 1578, 1579,  467, 1401,  462,  137,
- /*   310 */  1111, 1641,  568, 1190, 1651,  271, 1637, 1714, 1129,  431,
- /*   320 */  1249, 1250, 1252, 1253, 1104,  412, 1675, 1388,    7, 1288,
- /*   330 */   351, 1195,  137,  346,  345,  344,  343,  342, 1130,  339,
- /*   340 */   338,  337,  336,  335,  331,  330,  329,  328,  327,  326,
- /*   350 */   325,  568, 1547,   97,   96,   95,   94,   93,   92,   91,
- /*   360 */    90,   89, 1106, 1104, 1702, 1702,   25,  276, 1184, 1185,
- /*   370 */  1186, 1187, 1188, 1192, 1193, 1194,  361,  136, 1701, 1311,
- /*   380 */   521, 1700, 1700, 1109, 1110,  939, 1154, 1155, 1156, 1157,
- /*   390 */  1158, 1159, 1160,  464, 1165, 1166, 1167, 1168, 1169, 1170,
- /*   400 */  1171, 1106,  564,  563,  941,   34,   32,   30,   29,   28,
- /*   410 */    88,  396,  395,   87,   86,   85,   84,   83,   82,   81,
- /*   420 */    80,   79, 1109, 1110, 1547, 1154, 1155, 1156, 1157, 1158,
- /*   430 */  1159, 1160,  464, 1165, 1166, 1167, 1168, 1169, 1170, 1171,
- /*   440 */    33,   31, 1172,  251, 1289,  309, 1310,  282,  278, 1127,
- /*   450 */  1105,  288,  137,  485,  472,  121,  261,  100,  199,  121,
- /*   460 */  1504,  385,  332, 1412,  311,   88, 1103, 1412,   87,   86,
- /*   470 */    85,   84,   83,   82,   81,   80,   79, 1189, 1410,   33,
- /*   480 */    31,  143,  100, 1385,  388, 1111,  385,  278, 1309, 1105,
- /*   490 */  1575, 1547,   34,   32,   30,   29,   28,  485,  485,  262,
- /*   500 */  1386,  260,  259,    7,  384, 1103,   77,  333,   51,  388,
- /*   510 */  1322,   50,  291,  389, 1591,   34,   32,   30,   29,   28,
- /*   520 */   121,  469, 1410, 1410, 1111,  485,  568, 1190, 1412, 1308,
- /*   530 */  1459,  468,  401, 1547,  360, 1547,  290,  485, 1104,  121,
- /*   540 */  1459, 1457,    7, 1191,  106, 1195, 1407, 1413,  516,  521,
- /*   550 */  1410, 1458,   62,   73, 1576,  471, 1578, 1579,  467,  511,
- /*   560 */   462, 1196, 1410, 1641, 1340,  568,  524,  271, 1637, 1714,
- /*   570 */  1131,  519,  347, 1403, 1547, 1655, 1106, 1104, 1698, 1241,
- /*   580 */    25,  276, 1184, 1185, 1186, 1187, 1188, 1192, 1193, 1194,
- /*   590 */   515,  514,  513, 1575,  512,  451,   23, 1109, 1110, 1650,
- /*   600 */  1154, 1155, 1156, 1157, 1158, 1159, 1160,  464, 1165, 1166,
- /*   610 */  1167, 1168, 1169, 1170, 1171, 1106,  398, 1591,  392,  147,
- /*   620 */   146, 1281,  397, 1307,  447,  101, 1395,  393,  391,  525,
- /*   630 */   394, 1382,  518,  517,  468,  390, 1109, 1110, 1547, 1154,
- /*   640 */  1155, 1156, 1157, 1158, 1159, 1160,  464, 1165, 1166, 1167,
- /*   650 */  1168, 1169, 1170, 1171,   33,   31,   73, 1576,  471, 1578,
- /*   660 */  1579,  467,  278,  462, 1105, 1575, 1641, 1397, 1547,  485,
- /*   670 */   271, 1637,  131,   34,   32,   30,   29,   28, 1528,  485,
- /*   680 */  1103, 1306, 1226,  485,  444,  885,  537,  535,  482, 1591,
- /*   690 */   185, 1669,  292, 1568, 1410, 1393,  469, 1495, 1496, 1111,
- /*   700 */  1280,  380,  485,    6, 1410, 1566,  468,  177, 1410,  104,
- /*   710 */  1547,  483,  485, 1305, 1304, 1660, 1222,    1, 1337, 1234,
- /*   720 */  1303,  218, 1302, 1299, 1298, 1128, 1547, 1410,   73, 1576,
- /*   730 */   471, 1578, 1579,  467,  463,  462,  510, 1410, 1641, 1536,
- /*   740 */   568,  455,  271, 1637, 1714,  102,   34,   32,   30,   29,
- /*   750 */    28, 1297, 1104, 1659, 1296, 1295,  419, 1294, 1547, 1547,
- /*   760 */   134, 1648, 1649, 1293, 1653, 1547, 1301, 1547, 1547, 1547,
- /*   770 */   544,  543,  542,  541,  293,  301,  540,  539,  538,  107,
- /*   780 */   533,  532,  531,  530,  529,  528,  527,  526,  114,  522,
- /*   790 */  1106, 1177,  165,  459,  536,  163, 1547, 1128,  312, 1547,
- /*   800 */  1547,  120, 1547, 1292, 1091, 1092, 1291,  450, 1547, 1368,
- /*   810 */  1141, 1109, 1110,  201, 1154, 1155, 1156, 1157, 1158, 1159,
- /*   820 */  1160,  464, 1165, 1166, 1167, 1168, 1169, 1170, 1171,  432,
- /*   830 */   977,  508,  507,  506,  981,  505,  983,  984,  504,  986,
- /*   840 */   501, 1452,  992,  498,  994,  995,  495,  492, 1547,  122,
- /*   850 */  1575, 1547,  167,  169,  232,  166,  168,  171, 1222,  410,
- /*   860 */   170, 1320, 1114, 1575,  112,   47,  230,  188,  423, 1248,
- /*   870 */  1113,  190,  408,   35, 1591, 1283, 1284, 1197, 1225,  148,
- /*   880 */    35,  469,  413,  404, 1161,    9,    8, 1591,  456,   35,
- /*   890 */   379,  468,  207, 1066,  469, 1547,  209,  109,  194,  110,
- /*   900 */   448,  477, 1671,  215,  468,  112,   47,  490, 1547,  970,
- /*   910 */   965,  998, 1181,  239, 1576,  471, 1578, 1579,  467,  110,
- /*   920 */   462,  111,  445, 1002, 1592, 1009,   74, 1576,  471, 1578,
- /*   930 */  1579,  467,  203,  462, 1117,  911, 1641,    2, 1126, 1702,
- /*   940 */  1640, 1637, 1116,   71, 1575,  112,  296,  300,  256, 1008,
- /*   950 */   160,  110,  136,  130,  912,  113, 1700,  939,  258,  378,
- /*   960 */  1075,  374,  370,  366,  159,  223,  334, 1493, 1591,  144,
- /*   970 */   341,  349,   49,   48,  321,  469,  142,  354,  348,  350,
- /*   980 */  1135,  315,  355,  149, 1134,  468,  356,  152,  357, 1547,
- /*   990 */  1133,   54,  359,  257,  157,  307, 1575,  303,  299,  139,
- /*  1000 */   358,  155,   52,  362, 1132,  383,  381,   74, 1576,  471,
- /*  1010 */  1578, 1579,  467,  158,  462, 1400,  162, 1641,   78,  571,
- /*  1020 */  1591,  458, 1637,  266, 1396,  164, 1111,  466, 1532,  224,
- /*  1030 */   137,  115,  116,  222, 1398, 1394,   98,  468,  117,  118,
- /*  1040 */   175, 1547,  560,  414,  556,  552,  548,  221,  178,  415,
- /*  1050 */   418, 1575,  156,  180,  151,  422,  153, 1131,  424,  246,
- /*  1060 */  1576,  471, 1578, 1579,  467,  465,  462,  460, 1613,  183,
- /*  1070 */   425,  433, 1682,  150,   70, 1591,  475,  216, 1672, 1681,
- /*  1080 */   186,  430,  469,  189, 1662,  270,  436,  429,    5,  441,
- /*  1090 */     4, 1222,  468, 1130,   37, 1717, 1547,  103,  272, 1656,
- /*  1100 */  1575,  457,  196,  454,   16, 1622,  473,  481,  193,  478,
- /*  1110 */   479, 1502,  129,  474,  125, 1576,  471, 1578, 1579,  467,
- /*  1120 */   280,  462,  195, 1501, 1591,  211,  480,  225, 1699,  202,
- /*  1130 */   213,  469,   61,   63, 1411, 1383,  426,  227,  488,  181,
- /*  1140 */   220,  468,  567,   43,  128, 1547,  233,  234,  229,  231,
- /*  1150 */  1541, 1540, 1575,  295, 1083, 1537,  176,  297,  449, 1715,
- /*  1160 */   444,  298, 1099,   74, 1576,  471, 1578, 1579,  467, 1100,
- /*  1170 */   462,  140,  302, 1641, 1535,  304, 1591,  305, 1638,  306,
- /*  1180 */  1534,  308, 1575,  469, 1533,  104,  310, 1518,  141, 1078,
- /*  1190 */  1077,  313,  314,  468, 1512, 1511,  320, 1547,  319, 1510,
- /*  1200 */   428, 1509, 1486, 1049,  448, 1485, 1591, 1484, 1483, 1482,
- /*  1210 */  1481, 1480, 1479,  469,  108,  247, 1576,  471, 1578, 1579,
- /*  1220 */   467,  102,  462,  468, 1478, 1477, 1476, 1547, 1475, 1474,
- /*  1230 */  1473, 1472, 1471, 1575, 1470, 1469,  197, 1648,  443, 1468,
- /*  1240 */   442, 1467, 1466, 1702, 1465,  125, 1576,  471, 1578, 1579,
- /*  1250 */   467, 1464,  462, 1463, 1462, 1051,  136, 1591, 1461, 1460,
- /*  1260 */  1700, 1339, 1526, 1575,  469, 1520, 1508, 1499, 1389,  904,
- /*  1270 */   154, 1338, 1336, 1334,  468,  363,  364, 1332, 1547,  365,
- /*  1280 */  1330,  275,  368,  367,  372,  371,  369, 1591,  375, 1319,
- /*  1290 */  1716, 1575,  373,  376,  466,  377,  247, 1576,  471, 1578,
- /*  1300 */  1579,  467, 1318,  462,  468, 1315, 1391,   76, 1547, 1014,
- /*  1310 */  1390, 1328, 1017,  263, 1323, 1591,  938,  937, 1321,  936,
- /*  1320 */   161,  935,  469,  934,  931,  264,  246, 1576,  471, 1578,
- /*  1330 */  1579,  467,  468,  462,  930, 1614, 1547,  402,  265,  277,
- /*  1340 */  1575,  534,  285,  284, 1314,  405,  407, 1313,  536, 1105,
- /*  1350 */   409,   75, 1119, 1525,  247, 1576,  471, 1578, 1579,  467,
- /*  1360 */    46,  462, 1519, 1085, 1591, 1103,  119,  416, 1112, 1507,
- /*  1370 */  1506,  469, 1498,    3,   56,  182,   35, 1566, 1575,   13,
- /*  1380 */    41,  468,   14,   38, 1111, 1547,   11, 1111,  279, 1575,
- /*  1390 */    58,  187,  126,  179,  191,  417, 1247,   20,  184,  198,
- /*  1400 */    40,  192, 1591,  247, 1576,  471, 1578, 1579,  467,  469,
- /*  1410 */   462, 1240,   57, 1591,   21, 1219, 1218, 1274,   39,  468,
- /*  1420 */   469,  135,   15, 1547,    8,  568, 1269, 1268,  486,  273,
- /*  1430 */   468, 1273, 1272,  274, 1547,   17, 1164, 1104,  138, 1575,
- /*  1440 */  1115,  235, 1576,  471, 1578, 1579,  467, 1163,  462,  461,
- /*  1450 */    27, 1182,  241, 1576,  471, 1578, 1579,  467, 1162,  462,
- /*  1460 */    10, 1149,   18, 1591,  205,  470,  206,   19, 1497,  212,
- /*  1470 */   469,  476, 1245,  208,  210, 1106,   59,   60, 1120, 1121,
- /*  1480 */   468,   42,   64,  214, 1547,  999,  489, 1565,  287, 1575,
- /*  1490 */   217,  491,  493,  487,  996,  494, 1109, 1110,  496, 1123,
- /*  1500 */  1575,  993,  243, 1576,  471, 1578, 1579,  467,  497,  462,
- /*  1510 */   987,  499,  500, 1591,  985,  502,  503,  991,  976,  990,
- /*  1520 */   469,  989,   65,  988, 1591, 1011,   66,   67,  509, 1007,
- /*  1530 */   468,  469, 1004,  902, 1547,  520,  927, 1010,  945,  523,
- /*  1540 */   925,  468,  219,  924,  923, 1547,  922,  921, 1575,  920,
- /*  1550 */   919,  918,  236, 1576,  471, 1578, 1579,  467,  942,  462,
- /*  1560 */   940, 1575,  403,  244, 1576,  471, 1578, 1579,  467,  915,
- /*  1570 */   462,  914, 1591,  913,  910,  909,  908,  411,  907,  469,
- /*  1580 */  1335,  545,  546, 1333,  547, 1591,  549,  550,  551,  468,
- /*  1590 */  1331,  173,  469, 1547,  406,  553,  554,  555, 1329,  400,
- /*  1600 */   557,  558,  468, 1317,  559,  172, 1547,  561,  562, 1316,
- /*  1610 */  1312,  237, 1576,  471, 1578, 1579,  467,  565,  462, 1107,
- /*  1620 */   566,  570,  228,  569,  245, 1576,  471, 1578, 1579,  467,
- /*  1630 */  1575,  462,   45, 1287, 1287,   44, 1287, 1287, 1287, 1575,
- /*  1640 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1650 */  1287, 1287, 1287, 1287, 1591, 1287, 1287, 1287, 1287, 1287,
- /*  1660 */  1287,  469, 1287, 1591, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1670 */   469,  468, 1287, 1287, 1287, 1547, 1287, 1287, 1287, 1287,
- /*  1680 */   468, 1287, 1287, 1287, 1547, 1287, 1287, 1287, 1287, 1575,
- /*  1690 */  1287, 1287, 1287,  238, 1576,  471, 1578, 1579,  467, 1287,
- /*  1700 */   462, 1287, 1587, 1576,  471, 1578, 1579,  467, 1287,  462,
- /*  1710 */  1287, 1287, 1287, 1591, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1720 */   469, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1730 */   468, 1287, 1287, 1287, 1547, 1287, 1287, 1287, 1287, 1575,
- /*  1740 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1750 */  1575, 1287, 1586, 1576,  471, 1578, 1579,  467, 1287,  462,
- /*  1760 */  1287, 1287, 1287, 1591, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1770 */   469, 1287, 1287, 1287, 1591, 1287, 1287, 1287, 1287, 1287,
- /*  1780 */   468,  469, 1287, 1287, 1547, 1287, 1287, 1287, 1287, 1287,
- /*  1790 */  1287,  468, 1287, 1287, 1287, 1547, 1287, 1287, 1575, 1287,
- /*  1800 */  1287, 1287, 1585, 1576,  471, 1578, 1579,  467, 1287,  462,
- /*  1810 */  1287, 1575, 1287,  254, 1576,  471, 1578, 1579,  467, 1287,
- /*  1820 */   462, 1287, 1591, 1287, 1287, 1287, 1287, 1287, 1287,  469,
- /*  1830 */  1287, 1287, 1287, 1287, 1287, 1591, 1287, 1287, 1287,  468,
- /*  1840 */  1287, 1287,  469, 1547, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1850 */  1287, 1287,  468, 1287, 1287, 1287, 1547, 1287, 1287, 1287,
- /*  1860 */  1287,  253, 1576,  471, 1578, 1579,  467, 1287,  462, 1287,
- /*  1870 */  1287, 1287, 1287, 1287,  255, 1576,  471, 1578, 1579,  467,
- /*  1880 */  1575,  462, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1575,
- /*  1890 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1900 */  1287, 1287, 1287, 1287, 1591, 1287, 1287, 1287, 1287, 1287,
- /*  1910 */  1287,  469, 1287, 1591, 1287, 1287, 1287, 1287, 1287, 1287,
- /*  1920 */   469,  468, 1287, 1287, 1287, 1547, 1287, 1287, 1287, 1287,
- /*  1930 */   468, 1287, 1287, 1287, 1547, 1287, 1287, 1287, 1287, 1287,
- /*  1940 */  1287, 1287, 1287,  252, 1576,  471, 1578, 1579,  467, 1287,
- /*  1950 */   462, 1287,  240, 1576,  471, 1578, 1579,  467, 1287,  462,
+ /*     0 */   270, 1593,  287,  472, 1577,  485,  282,  325,  469, 1505,
+ /*    10 */  1288, 1401,   33,   31,   78, 1577,  124, 1563, 1302, 1563,
+ /*    20 */   279,  383, 1106,   34,   32,   30,   29,   28, 1593, 1563,
+ /*    30 */  1412, 1559, 1565, 1559, 1565,  469,  125,  250, 1104, 1593,
+ /*    40 */  1369, 1705,  438, 1559, 1566,  468,  469, 1389,  445, 1549,
+ /*    50 */    12,   33,   31, 1228, 1704,   54,  468, 1112, 1702,  279,
+ /*    60 */  1549, 1106,  484,  295,  319,  449, 1577,  243, 1578,  471,
+ /*    70 */  1580, 1581,  467,  105,  462,    1, 1408, 1104,   73, 1578,
+ /*    80 */   471, 1580, 1581,  467,  525,  462, 1384,  290, 1643,   12,
+ /*    90 */  1593,  484,  251, 1639, 1496, 1498, 1112,  448,  568,   26,
+ /*   100 */   205,  362, 1705, 1705, 1705,  441,  421,  468,  107,  103,
+ /*   110 */  1105, 1549,  516,  485,    1,  137,  137,  137, 1129, 1702,
+ /*   120 */  1702, 1702,  323,  447,  133, 1650, 1651,  445, 1655,   74,
+ /*   130 */  1578,  471, 1580, 1581,  467,  519,  462,  568, 1412, 1643,
+ /*   140 */    54,  144,  485,  272, 1639,  132,   36,  940, 1107, 1105,
+ /*   150 */   422,  324,  105,  100,  515,  514,  513,  201,  512, 1127,
+ /*   160 */   439, 1407, 1130,  428, 1670,  435,  942, 1412,   52, 1110,
+ /*   170 */  1111,   51, 1155, 1156, 1157, 1158, 1159, 1160, 1161,  464,
+ /*   180 */  1166, 1167, 1168, 1169, 1170, 1171, 1172, 1107,  103, 1705,
+ /*   190 */  1461,   34,   32,   30,   29,   28,  269,    9,    8,  138,
+ /*   200 */    69, 1459,  137,  134, 1650, 1651, 1702, 1655, 1110, 1111,
+ /*   210 */    65, 1155, 1156, 1157, 1158, 1159, 1160, 1161,  464, 1166,
+ /*   220 */  1167, 1168, 1169, 1170, 1171, 1172,   33,   31,  138,  252,
+ /*   230 */   227,  440,  436, 1442,  279,  249, 1106, 1127, 1577,  399,
+ /*   240 */    63,  393,  521, 1461,  341,  398,   70,  353,  102,  284,
+ /*   250 */   394,  392, 1104,  395, 1459, 1142,  354,  318,  391,  317,
+ /*   260 */   106, 1405, 1593, 1190,   12,   33,   31, 1404, 1227,  469,
+ /*   270 */   138, 1112, 1204,  279,   22, 1106, 1657,   56,  268,  468,
+ /*   280 */  1252,  175,   24, 1549,   34,   32,   30,   29,   28,    1,
+ /*   290 */  1657, 1104,   34,   32,   30,   29,   28,   30,   29,   28,
+ /*   300 */  1654,   74, 1578,  471, 1580, 1581,  467,  128,  462,  138,
+ /*   310 */  1112, 1643,  568, 1191, 1653,  272, 1639, 1717, 1453,  432,
+ /*   320 */  1250, 1251, 1253, 1254, 1105,  413, 1677, 1390,    7, 1290,
+ /*   330 */   352, 1196, 1128,  347,  346,  345,  344,  343,  138,  340,
+ /*   340 */   339,  338,  337,  336,  332,  331,  330,  329,  328,  327,
+ /*   350 */   326,  568,   59,   98,   97,   96,   95,   94,   93,   92,
+ /*   360 */    91,   90, 1107, 1105, 1705, 1705,   25,  277, 1185, 1186,
+ /*   370 */  1187, 1188, 1189, 1193, 1194, 1195,  362,  137, 1703, 1403,
+ /*   380 */  1131, 1702, 1702, 1110, 1111,    6, 1155, 1156, 1157, 1158,
+ /*   390 */  1159, 1160, 1161,  464, 1166, 1167, 1168, 1169, 1170, 1171,
+ /*   400 */  1172, 1107,  524,  484,  452,   34,   32,   30,   29,   28,
+ /*   410 */    89,  564,  563,   88,   87,   86,   85,   84,   83,   82,
+ /*   420 */    81,   80, 1110, 1111, 1549, 1155, 1156, 1157, 1158, 1159,
+ /*   430 */  1160, 1161,  464, 1166, 1167, 1168, 1169, 1170, 1171, 1172,
+ /*   440 */    33,   31, 1173,  252, 1291,  536, 1313,  283,  279,  313,
+ /*   450 */  1106,  289,  138,  485,  472,  122,  262,  101,   36,  122,
+ /*   460 */  1506,  386,  333, 1414, 1226,   89, 1104, 1414,   88,   87,
+ /*   470 */    86,   85,   84,   83,   82,   81,   80, 1190, 1412,   33,
+ /*   480 */    31,   48,  101, 1387,  389, 1112,  386,  279, 1312, 1106,
+ /*   490 */  1577, 1549,   34,   32,   30,   29,   28,  485,  485,  263,
+ /*   500 */   200,  261,  260,    7,  385, 1104,   78,  334,  511,  389,
+ /*   510 */   388,  387,  292,  390, 1593,   34,   32,   30,   29,   28,
+ /*   520 */   122,  469, 1412, 1412, 1112,  485,  568, 1191, 1414, 1311,
+ /*   530 */  1461,  468, 1493, 1549,  361, 1549,  291,  485, 1105,  146,
+ /*   540 */  1223, 1459,    7, 1192,  107, 1196, 1409,  138,  516,  453,
+ /*   550 */  1412,  397,  396,   74, 1578,  471, 1580, 1581,  467, 1461,
+ /*   560 */   462, 1197, 1412, 1643, 1342,  568, 1132,  272, 1639, 1717,
+ /*   570 */  1460,  519,  348, 1397, 1549, 1657, 1107, 1105, 1700, 1242,
+ /*   580 */    25,  277, 1185, 1186, 1187, 1188, 1189, 1193, 1194, 1195,
+ /*   590 */   515,  514,  513, 1577,  512, 1538,   23, 1110, 1111, 1652,
+ /*   600 */  1155, 1156, 1157, 1158, 1159, 1160, 1161,  464, 1166, 1167,
+ /*   610 */  1168, 1169, 1170, 1171, 1172, 1107,  399, 1593,  393,  148,
+ /*   620 */   147, 1283,  398, 1310,  448,  102,  166,  394,  392,  164,
+ /*   630 */   395,  302,  518,  517,  468,  391, 1110, 1111, 1549, 1155,
+ /*   640 */  1156, 1157, 1158, 1159, 1160, 1161,  464, 1166, 1167, 1168,
+ /*   650 */  1169, 1170, 1171, 1172,   33,   31,   74, 1578,  471, 1580,
+ /*   660 */  1581,  467,  279,  462, 1106, 1577, 1643, 1388, 1549,  485,
+ /*   670 */   272, 1639,  132,   34,   32,   30,   29,   28, 1530,  485,
+ /*   680 */  1104, 1309,  122,  485,  445,  887,  186,  886,  482, 1593,
+ /*   690 */  1415, 1671,  293,  451, 1412, 1399,  469,  537,  535, 1112,
+ /*   700 */  1282, 1235,  485,  886, 1412,  888,  468, 1129, 1412,  105,
+ /*   710 */  1549,  483,  485, 1308, 1307,  310,  521,    1, 1339,  381,
+ /*   720 */  1306,  219, 1305, 1304, 1301, 1395, 1549, 1412,   74, 1578,
+ /*   730 */   471, 1580, 1581,  467,  312,  462,  168, 1412, 1643,  167,
+ /*   740 */   568,  455,  272, 1639, 1717,  103,   34,   32,   30,   29,
+ /*   750 */    28, 1300, 1105, 1661, 1299, 1298,  178, 1297, 1549, 1549,
+ /*   760 */   135, 1650, 1651, 1296, 1655, 1549,  459, 1549, 1549, 1549,
+ /*   770 */   544,  543,  542,  541,  294,  463,  540,  539,  538,  108,
+ /*   780 */   533,  532,  531,  530,  529,  528,  527,  526,  115,  522,
+ /*   790 */  1107, 1178, 1497, 1498, 1662, 1223, 1549, 1129,  510, 1549,
+ /*   800 */  1549,  121, 1549, 1295, 1092, 1093, 1294, 1293, 1549,  113,
+ /*   810 */  1142, 1110, 1111,  424, 1155, 1156, 1157, 1158, 1159, 1160,
+ /*   820 */  1161,  464, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1570,
+ /*   830 */   978,  508,  507,  506,  982,  505,  984,  985,  504,  987,
+ /*   840 */   501, 1568,  993,  498,  995,  996,  495,  492, 1549,  123,
+ /*   850 */  1577, 1549, 1549,  170,  233, 1329,  169,  172, 1324,  411,
+ /*   860 */   171, 1322, 1115, 1577,   47,  189,  231,  420, 1249,  191,
+ /*   870 */     9,    8,  409, 1114, 1593, 1285, 1286,  400,   35,  149,
+ /*   880 */   402,  469, 1198,  405, 1303, 1182,   35, 1593,  456,   35,
+ /*   890 */  1162,  468,  208, 1067,  469, 1549,  210,  110, 1370,  111,
+ /*   900 */   449,  477,  113,  216,  468,   47,  971,  202, 1549,  966,
+ /*   910 */   433, 1454,  414,  240, 1578,  471, 1580, 1581,  467,  490,
+ /*   920 */   462,  111,  195,  999,  380, 1003,   75, 1578,  471, 1580,
+ /*   930 */  1581,  467,  446,  462, 1118, 1673, 1643, 1594,  112, 1705,
+ /*   940 */  1642, 1639, 1010,   72, 1577, 1117,  204,  912,    2,  301,
+ /*   950 */   161,  113,  137,  131,  111, 1009, 1702, 1127,  114,  379,
+ /*   960 */   297,  375,  371,  367,  160,  257,  913,  259, 1593,  940,
+ /*   970 */   224,  335,   50,   49,  322,  469,  143, 1495, 1076,  342,
+ /*   980 */   145,  316,  350,  349,  351,  468,  355, 1136,  356, 1549,
+ /*   990 */   150,   55,  357,  258,  158,  308, 1577,  304,  300,  140,
+ /*  1000 */  1135,  358,  153,  359, 1134,  360,  156,   75, 1578,  471,
+ /*  1010 */  1580, 1581,  467,   53,  462,  363,  159, 1643, 1133,  571,
+ /*  1020 */  1593,  458, 1639,  382,  384, 1402,   79,  466,  163,  267,
+ /*  1030 */   138, 1398, 1112,  223,  165,  116,   99,  468,  117, 1400,
+ /*  1040 */  1396, 1549,  560,  118,  556,  552,  548,  222,  119,  176,
+ /*  1050 */   225, 1577,  157,  415,  152,  423,  154, 1534,  179,  247,
+ /*  1060 */  1578,  471, 1580, 1581,  467,  465,  462,  460, 1615,  419,
+ /*  1070 */   181,  425,  426,  151,   71, 1593,  416,  217, 1132,  434,
+ /*  1080 */   184,  187,  469, 1684,  475, 1674,  431, 1683,    5,  190,
+ /*  1090 */   442,  271,  468,  437,  430,    4, 1549, 1223,  104, 1131,
+ /*  1100 */  1577,  273,   37, 1720,  457,  454,  197,  481, 1658, 1664,
+ /*  1110 */    16,  473, 1624,  474,  126, 1578,  471, 1580, 1581,  467,
+ /*  1120 */   194,  462,  130, 1504, 1593,  196,  478, 1503,  226,  212,
+ /*  1130 */   281,  469,  479,  214,  480,   62,  427, 1701,  203,  182,
+ /*  1140 */  1413,  468,   64,  488,  221, 1549, 1385,  228,  567,  129,
+ /*  1150 */   230,  234, 1577,   43, 1084,  235,  177,  232,  450, 1718,
+ /*  1160 */   445, 1543, 1542,   75, 1578,  471, 1580, 1581,  467,  296,
+ /*  1170 */   462, 1539,  298, 1643,  299, 1100, 1593, 1101, 1640,  141,
+ /*  1180 */   303, 1537, 1577,  469,  305,  105,  306,  307, 1536,  309,
+ /*  1190 */  1535, 1520,  311,  468,  142,  314,  315, 1549, 1079, 1078,
+ /*  1200 */   429, 1514, 1513,  320,  449,  321, 1593, 1512, 1511, 1050,
+ /*  1210 */  1488, 1487, 1486,  469,  109,  248, 1578,  471, 1580, 1581,
+ /*  1220 */   467,  103,  462,  468, 1485, 1484, 1483, 1549, 1482, 1481,
+ /*  1230 */  1480, 1479, 1478, 1577, 1477, 1476,  198, 1650,  444, 1475,
+ /*  1240 */   443, 1474, 1473, 1705, 1472,  126, 1578,  471, 1580, 1581,
+ /*  1250 */   467, 1471,  462, 1470, 1469, 1468,  137, 1593, 1467, 1466,
+ /*  1260 */  1702, 1465, 1052, 1577,  469, 1464, 1463, 1462, 1341, 1528,
+ /*  1270 */  1522, 1510, 1501, 1391,  468,  162,  155, 1340, 1549, 1338,
+ /*  1280 */  1336,  276,  365,  364,  369,  368,  366, 1593,  905, 1334,
+ /*  1290 */  1719, 1577,  370,  374,  466,  372,  248, 1578,  471, 1580,
+ /*  1300 */  1581,  467, 1332,  462,  468,  378, 1321, 1320, 1549, 1317,
+ /*  1310 */   373, 1393, 1015, 1392, 1018, 1593,  376,  377, 1330,  264,
+ /*  1320 */    77,  939,  469,  938,  534,  937,  247, 1578,  471, 1580,
+ /*  1330 */  1581,  467,  468,  462,  936, 1616, 1549,  935,  932,  278,
+ /*  1340 */  1577,  931,  286,  285, 1325, 1323,  265,  403,  266, 1106,
+ /*  1350 */   406, 1316, 1120,  408,  248, 1578,  471, 1580, 1581,  467,
+ /*  1360 */   536,  462, 1315,  410, 1593, 1104,   76, 1527, 1113, 1521,
+ /*  1370 */  1086,  469,  120, 1509,  417,  180, 1508, 1500, 1577,   57,
+ /*  1380 */   183,  468,    3,   13, 1112, 1549,   35, 1112,  280, 1577,
+ /*  1390 */    14,  188,   41, 1248,  127,   38,   46,  192,  185,   11,
+ /*  1400 */   418, 1241, 1593,  248, 1578,  471, 1580, 1581,  467,  469,
+ /*  1410 */   462, 1220,  193, 1593,   20, 1568,  199,   58, 1271,  468,
+ /*  1420 */   469,   21,   40, 1549, 1219,  568,   39,   15,  486, 1276,
+ /*  1430 */   468, 1270,  274, 1275, 1549, 1274,  275, 1105,    8, 1577,
+ /*  1440 */  1116,  236, 1578,  471, 1580, 1581,  467,  136,  462,  461,
+ /*  1450 */    17, 1165,  242, 1578,  471, 1580, 1581,  467, 1164,  462,
+ /*  1460 */  1183,   27,   10, 1593, 1163,   18,  139, 1150,  206,  470,
+ /*  1470 */   469,   19,  476, 1499,  209, 1107,  207, 1246, 1121,  211,
+ /*  1480 */   468,   60,  213,   61, 1549,  215,   42,   65, 1122, 1577,
+ /*  1490 */  1567, 1000,  489,  288,  218,  487, 1110, 1111,  491, 1124,
+ /*  1500 */  1577,  997,  244, 1578,  471, 1580, 1581,  467,  493,  462,
+ /*  1510 */   494,  977,  496, 1593,  994,  497,  499,  988,  500,  502,
+ /*  1520 */   469,  992,  986,  503, 1593,  509,  991,  990,  989, 1012,
+ /*  1530 */   468,  469,   66,   67, 1549,   68, 1008, 1005,  903, 1011,
+ /*  1540 */   520,  468,  928,  946,  523, 1549,  926,  220, 1577,  925,
+ /*  1550 */   924,  923,  237, 1578,  471, 1580, 1581,  467,  922,  462,
+ /*  1560 */   921, 1577,  404,  245, 1578,  471, 1580, 1581,  467,  920,
+ /*  1570 */   462,  919, 1593,  943,  941,  916,  915,  412,  914,  469,
+ /*  1580 */   911,  910,  909,  908, 1337, 1593,  545,  546, 1335,  468,
+ /*  1590 */   547,  174,  469, 1549,  407,  549,  550,  551, 1333,  401,
+ /*  1600 */   553,  554,  468, 1331,  555,  173, 1549,  557,  558,  559,
+ /*  1610 */  1319,  238, 1578,  471, 1580, 1581,  467,  561,  462,  562,
+ /*  1620 */  1318, 1314,  565,  566,  246, 1578,  471, 1580, 1581,  467,
+ /*  1630 */  1577,  462,   45, 1108,  229,   44,  569,  570, 1289, 1577,
+ /*  1640 */  1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1650 */  1289, 1289, 1289, 1289, 1593, 1289, 1289, 1289, 1289, 1289,
+ /*  1660 */  1289,  469, 1289, 1593, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1670 */   469,  468, 1289, 1289, 1289, 1549, 1289, 1289, 1289, 1289,
+ /*  1680 */   468, 1289, 1289, 1289, 1549, 1289, 1289, 1289, 1289, 1577,
+ /*  1690 */  1289, 1289, 1289,  239, 1578,  471, 1580, 1581,  467, 1289,
+ /*  1700 */   462, 1289, 1589, 1578,  471, 1580, 1581,  467, 1289,  462,
+ /*  1710 */  1289, 1289, 1289, 1593, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1720 */   469, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1730 */   468, 1289, 1289, 1289, 1549, 1289, 1289, 1289, 1289, 1577,
+ /*  1740 */  1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1750 */  1577, 1289, 1588, 1578,  471, 1580, 1581,  467, 1289,  462,
+ /*  1760 */  1289, 1289, 1289, 1593, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1770 */   469, 1289, 1289, 1289, 1593, 1289, 1289, 1289, 1289, 1289,
+ /*  1780 */   468,  469, 1289, 1289, 1549, 1289, 1289, 1289, 1289, 1289,
+ /*  1790 */  1289,  468, 1289, 1289, 1289, 1549, 1289, 1289, 1577, 1289,
+ /*  1800 */  1289, 1289, 1587, 1578,  471, 1580, 1581,  467, 1289,  462,
+ /*  1810 */  1289, 1577, 1289,  255, 1578,  471, 1580, 1581,  467, 1289,
+ /*  1820 */   462, 1289, 1593, 1289, 1289, 1289, 1289, 1289, 1289,  469,
+ /*  1830 */  1289, 1289, 1289, 1289, 1289, 1593, 1289, 1289, 1289,  468,
+ /*  1840 */  1289, 1289,  469, 1549, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1850 */  1289, 1289,  468, 1289, 1289, 1289, 1549, 1289, 1289, 1289,
+ /*  1860 */  1289,  254, 1578,  471, 1580, 1581,  467, 1289,  462, 1289,
+ /*  1870 */  1289, 1289, 1289, 1289,  256, 1578,  471, 1580, 1581,  467,
+ /*  1880 */  1577,  462, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1577,
+ /*  1890 */  1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1900 */  1289, 1289, 1289, 1289, 1593, 1289, 1289, 1289, 1289, 1289,
+ /*  1910 */  1289,  469, 1289, 1593, 1289, 1289, 1289, 1289, 1289, 1289,
+ /*  1920 */   469,  468, 1289, 1289, 1289, 1549, 1289, 1289, 1289, 1289,
+ /*  1930 */   468, 1289, 1289, 1289, 1549, 1289, 1289, 1289, 1289, 1289,
+ /*  1940 */  1289, 1289, 1289,  253, 1578,  471, 1580, 1581,  467, 1289,
+ /*  1950 */   462, 1289,  241, 1578,  471, 1580, 1581,  467, 1289,  462,
 };
 static const YYCODETYPE yy_lookahead[] = {
  /*     0 */   253,  249,  253,  266,  225,  231,  269,  231,  256,  272,
  /*    10 */   222,  250,   12,   13,  240,  225,  224,  270,  226,  270,
  /*    20 */    20,  247,   22,   12,   13,   14,   15,   16,  249,  270,
  /*    30 */   256,  284,  285,  284,  285,  256,  234,  261,   38,  249,
- /*    40 */   238,  233,  290,  284,  285,  266,  256,    0,  231,  270,
- /*    50 */    50,   12,   13,   14,  246,  233,  266,   57,   20,   20,
- /*    60 */   270,   22,  254,  275,  275,  275,  225,  288,  289,  290,
+ /*    40 */   238,  314,  290,  284,  285,  266,  256,    0,  231,  270,
+ /*    50 */    50,   12,   13,   14,  327,  233,  266,   57,  331,   20,
+ /*    60 */   270,   22,   20,  275,  275,  275,  225,  288,  289,  290,
  /*    70 */   291,  292,  293,  256,  295,   75,  254,   38,  288,  289,
- /*    80 */   290,  291,  292,  293,   49,  295,   20,  258,  298,   50,
+ /*    80 */   290,  291,  292,  293,  237,  295,  239,  258,  298,   50,
  /*    90 */   249,   20,  302,  303,  265,  266,   57,  256,   98,  299,
- /*   100 */   300,   72,  314,  314,  314,  326,  231,  266,   61,  292,
- /*   110 */   110,  270,   65,  231,   75,  327,  327,  327,    0,  331,
+ /*   100 */   300,   49,  314,  314,  314,  326,  231,  266,   61,  292,
+ /*   110 */   110,  270,   65,  231,   75,  327,  327,  327,   20,  331,
  /*   120 */   331,  331,  240,  306,  307,  308,  309,  231,  311,  288,
  /*   130 */   289,  290,  291,  292,  293,   88,  295,   98,  256,  298,
- /*   140 */    22,   75,  231,  302,  303,  304,   75,  230,  148,  110,
- /*   150 */   275,  240,  256,   20,  107,  108,  109,  316,  111,  256,
- /*   160 */   248,  244,   20,  322,  323,  138,  263,  256,  251,  169,
- /*   170 */   170,  259,  172,  173,  174,  175,  176,  177,  178,  179,
+ /*   140 */   233,   47,  231,  302,  303,  304,   75,   38,  148,  110,
+ /*   150 */   275,  240,  256,  246,  107,  108,  109,  316,  111,   20,
+ /*   160 */    20,  254,   20,  322,  323,  138,   57,  256,   74,  169,
+ /*   170 */   170,   77,  172,  173,  174,  175,  176,  177,  178,  179,
  /*   180 */   180,  181,  182,  183,  184,  185,  186,  148,  292,  314,
  /*   190 */   249,   12,   13,   14,   15,   16,  255,    1,    2,  199,
  /*   200 */    75,  260,  327,  307,  308,  309,  331,  311,  169,  170,
  /*   210 */    85,  172,  173,  174,  175,  176,  177,  178,  179,  180,
- /*   220 */   181,  182,  183,  184,  185,  186,   12,   13,   20,   50,
+ /*   220 */   181,  182,  183,  184,  185,  186,   12,   13,  199,   50,
  /*   230 */   242,  204,  205,  245,   20,   18,   22,   20,  225,   52,
- /*   240 */    20,   54,   22,  249,   27,   58,  217,   30,   61,  255,
+ /*   240 */   230,   54,   49,  249,   27,   58,  230,   30,   61,  255,
  /*   250 */    63,   64,   38,   66,  260,   76,   39,  147,   71,  149,
- /*   260 */    40,  199,  249,   84,   50,   12,   13,  235,  236,  256,
+ /*   260 */   244,  251,  249,   84,   50,   12,   13,  251,    4,  256,
  /*   270 */   199,   57,   76,   20,    2,   22,  286,  157,  158,  266,
  /*   280 */   169,  161,    2,  270,   12,   13,   14,   15,   16,   75,
  /*   290 */   286,   38,   12,   13,   14,   15,   16,   14,   15,   16,
- /*   300 */   310,  288,  289,  290,  291,  292,  293,  225,  295,  199,
- /*   310 */    57,  298,   98,  134,  310,  302,  303,  304,   20,  208,
+ /*   300 */   310,  288,  289,  290,  291,  292,  293,  248,  295,  199,
+ /*   310 */    57,  298,   98,  134,  310,  302,  303,  304,  259,  208,
  /*   320 */   209,  210,  211,  212,  110,  275,  313,    0,   75,    0,
- /*   330 */   113,  152,  199,  116,  117,  118,  119,  120,   20,  122,
+ /*   330 */   113,  152,   20,  116,  117,  118,  119,  120,  199,  122,
  /*   340 */   123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
- /*   350 */   133,   98,  270,   24,   25,   26,   27,   28,   29,   30,
+ /*   350 */   133,   98,    4,   24,   25,   26,   27,   28,   29,   30,
  /*   360 */    31,   32,  148,  110,  314,  314,  187,  188,  189,  190,
  /*   370 */   191,  192,  193,  194,  195,  196,   49,  327,  327,  225,
- /*   380 */    49,  331,  331,  169,  170,   38,  172,  173,  174,  175,
+ /*   380 */    20,  331,  331,  169,  170,   43,  172,  173,  174,  175,
  /*   390 */   176,  177,  178,  179,  180,  181,  182,  183,  184,  185,
- /*   400 */   186,  148,  228,  229,   57,   12,   13,   14,   15,   16,
- /*   410 */    21,  235,  236,   24,   25,   26,   27,   28,   29,   30,
+ /*   400 */   186,  148,   57,   20,   72,   12,   13,   14,   15,   16,
+ /*   410 */    21,  228,  229,   24,   25,   26,   27,   28,   29,   30,
  /*   420 */    31,   32,  169,  170,  270,  172,  173,  174,  175,  176,
  /*   430 */   177,  178,  179,  180,  181,  182,  183,  184,  185,  186,
- /*   440 */    12,   13,   14,   50,    0,  144,  225,  241,   20,   20,
- /*   450 */    22,  241,  199,  231,  266,  249,   35,   61,  140,  249,
- /*   460 */   272,   65,  240,  257,  163,   21,   38,  257,   24,   25,
+ /*   440 */    12,   13,   14,   50,    0,   72,  225,  241,   20,   76,
+ /*   450 */    22,  241,  199,  231,  266,  249,   35,   61,   75,  249,
+ /*   460 */   272,   65,  240,  257,  200,   21,   38,  257,   24,   25,
  /*   470 */    26,   27,   28,   29,   30,   31,   32,   84,  256,   12,
- /*   480 */    13,   47,   61,    0,   88,   57,   65,   20,  225,   22,
+ /*   480 */    13,    3,   61,    0,   88,   57,   65,   20,  225,   22,
  /*   490 */   225,  270,   12,   13,   14,   15,   16,  231,  231,   78,
- /*   500 */     0,   80,   81,   75,   83,   38,  240,  240,   74,   88,
- /*   510 */     0,   77,  241,  247,  249,   12,   13,   14,   15,   16,
+ /*   500 */   140,   80,   81,   75,   83,   38,  240,  240,   86,   88,
+ /*   510 */   235,  236,  241,  247,  249,   12,   13,   14,   15,   16,
  /*   520 */   249,  256,  256,  256,   57,  231,   98,  134,  257,  225,
- /*   530 */   249,  266,   22,  270,  240,  270,  255,  231,  110,  249,
- /*   540 */   249,  260,   75,  134,   61,  152,  240,  257,   65,   49,
- /*   550 */   256,  260,  230,  288,  289,  290,  291,  292,  293,   86,
- /*   560 */   295,  152,  256,  298,    0,   98,   57,  302,  303,  304,
- /*   570 */    20,   88,   67,  251,  270,  286,  148,  110,  313,   76,
+ /*   530 */   249,  266,  256,  270,  240,  270,  255,  231,  110,  263,
+ /*   540 */   198,  260,   75,  134,   61,  152,  240,  199,   65,  217,
+ /*   550 */   256,  235,  236,  288,  289,  290,  291,  292,  293,  249,
+ /*   560 */   295,  152,  256,  298,    0,   98,   20,  302,  303,  304,
+ /*   570 */   260,   88,   67,  250,  270,  286,  148,  110,  313,   76,
  /*   580 */   187,  188,  189,  190,  191,  192,  193,  194,  195,  196,
- /*   590 */   107,  108,  109,  225,  111,    3,  187,  169,  170,  310,
+ /*   590 */   107,  108,  109,  225,  111,    0,  187,  169,  170,  310,
  /*   600 */   172,  173,  174,  175,  176,  177,  178,  179,  180,  181,
  /*   610 */   182,  183,  184,  185,  186,  148,   52,  249,   54,  114,
- /*   620 */   115,  141,   58,  225,  256,   61,  250,   63,   64,  237,
- /*   630 */    66,  239,  235,  236,  266,   71,  169,  170,  270,  172,
+ /*   620 */   115,  141,   58,  225,  256,   61,   79,   63,   64,   82,
+ /*   630 */    66,   36,  235,  236,  266,   71,  169,  170,  270,  172,
  /*   640 */   173,  174,  175,  176,  177,  178,  179,  180,  181,  182,
  /*   650 */   183,  184,  185,  186,   12,   13,  288,  289,  290,  291,
- /*   660 */   292,  293,   20,  295,   22,  225,  298,  250,  270,  231,
+ /*   660 */   292,  293,   20,  295,   22,  225,  298,    0,  270,  231,
  /*   670 */   302,  303,  304,   12,   13,   14,   15,   16,  240,  231,
- /*   680 */    38,  225,    4,  231,  231,   22,  235,  236,  240,  249,
- /*   690 */   140,  323,  240,   75,  256,  250,  256,  265,  266,   57,
- /*   700 */   220,   38,  231,   43,  256,   87,  266,  250,  256,  256,
- /*   710 */   270,  240,  231,  225,  225,  197,  198,   75,    0,   14,
- /*   720 */   225,  240,  225,  225,  225,   20,  270,  256,  288,  289,
- /*   730 */   290,  291,  292,  293,  250,  295,  250,  256,  298,    0,
+ /*   680 */    38,  225,  249,  231,  231,   20,  140,   22,  240,  249,
+ /*   690 */   257,  323,  240,  215,  256,  250,  256,  235,  236,   57,
+ /*   700 */   220,   14,  231,   22,  256,   40,  266,   20,  256,  256,
+ /*   710 */   270,  240,  231,  225,  225,  144,   49,   75,    0,   38,
+ /*   720 */   225,  240,  225,  225,  225,  250,  270,  256,  288,  289,
+ /*   730 */   290,  291,  292,  293,  163,  295,   79,  256,  298,   82,
  /*   740 */    98,   72,  302,  303,  304,  292,   12,   13,   14,   15,
- /*   750 */    16,  225,  110,  313,  225,  225,  278,  225,  270,  270,
- /*   760 */   307,  308,  309,  225,  311,  270,  226,  270,  270,  270,
- /*   770 */    52,   53,   54,   55,   56,   36,   58,   59,   60,   61,
+ /*   750 */    16,  225,  110,  313,  225,  225,  250,  225,  270,  270,
+ /*   760 */   307,  308,  309,  225,  311,  270,   50,  270,  270,  270,
+ /*   770 */    52,   53,   54,   55,   56,  250,   58,   59,   60,   61,
  /*   780 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
- /*   790 */   148,   14,   79,   50,   72,   82,  270,   20,   76,  270,
- /*   800 */   270,  140,  270,  225,  159,  160,  225,  215,  270,  238,
- /*   810 */    76,  169,  170,  334,  172,  173,  174,  175,  176,  177,
- /*   820 */   178,  179,  180,  181,  182,  183,  184,  185,  186,  325,
+ /*   790 */   148,   14,  265,  266,  197,  198,  270,   20,  250,  270,
+ /*   800 */   270,  140,  270,  225,  159,  160,  225,  225,  270,   72,
+ /*   810 */    76,  169,  170,   76,  172,  173,  174,  175,  176,  177,
+ /*   820 */   178,  179,  180,  181,  182,  183,  184,  185,  186,   75,
  /*   830 */    89,   90,   91,   92,   93,   94,   95,   96,   97,   98,
- /*   840 */    99,  259,  101,  102,  103,  104,  105,  106,  270,   18,
- /*   850 */   225,  270,   79,   79,   23,   82,   82,   79,  198,   21,
- /*   860 */    82,    0,   38,  225,   72,   72,   35,   72,   76,   76,
- /*   870 */    38,   76,   34,   72,  249,  184,  185,   76,  200,   48,
- /*   880 */    72,  256,  282,   22,   76,    1,    2,  249,  219,   72,
- /*   890 */   228,  266,   72,   76,  256,  270,   76,   72,  319,   72,
- /*   900 */   275,   76,  287,   76,  266,   72,   72,   72,  270,   76,
- /*   910 */    76,   76,  169,  288,  289,  290,  291,  292,  293,   72,
- /*   920 */   295,   72,  312,   76,  249,   76,  288,  289,  290,  291,
- /*   930 */   292,  293,  328,  295,  110,   38,  298,  315,   20,  314,
- /*   940 */   302,  303,  110,  112,  225,   72,  231,   36,  283,   76,
- /*   950 */    33,   72,  327,   36,   57,   76,  331,   38,  235,   42,
- /*   960 */   146,   44,   45,   46,   47,  276,  231,  231,  249,  121,
- /*   970 */   264,  134,  141,  142,  143,  256,  145,  231,  262,  262,
- /*   980 */    20,  150,  280,  233,   20,  266,  266,  233,  274,  270,
- /*   990 */    20,   74,  267,  162,   77,  164,  225,  166,  167,  168,
- /*  1000 */   256,  233,  233,  231,   20,  249,  227,  288,  289,  290,
- /*  1010 */   291,  292,  293,  233,  295,  249,  249,  298,  231,   19,
- /*  1020 */   249,  302,  303,  227,  249,  249,   57,  256,  270,  280,
- /*  1030 */   199,  249,  249,   33,  249,  249,   36,  266,  249,  249,
- /*  1040 */   230,  270,   42,  155,   44,   45,   46,   47,  230,  279,
- /*  1050 */   266,  225,  135,  230,  137,  274,  139,   20,  256,  288,
- /*  1060 */   289,  290,  291,  292,  293,  294,  295,  296,  297,  230,
- /*  1070 */   267,  207,  324,  156,   74,  249,  206,   77,  287,  324,
- /*  1080 */   271,  270,  256,  271,  321,  270,  270,  202,  214,  213,
- /*  1090 */   201,  198,  266,   20,  121,  335,  270,  256,  221,  286,
- /*  1100 */   225,  218,  305,  216,   75,  301,  270,  107,  320,  137,
- /*  1110 */   268,  271,  318,  270,  288,  289,  290,  291,  292,  293,
- /*  1120 */   270,  295,  317,  271,  249,  256,  267,  245,  330,  329,
- /*  1130 */   230,  256,  230,   75,  256,  239,  136,  231,  252,  139,
- /*  1140 */   230,  266,  227,  277,  281,  270,  243,  243,  232,  223,
- /*  1150 */     0,    0,  225,   64,  154,    0,  156,   38,  332,  333,
- /*  1160 */   231,  165,   38,  288,  289,  290,  291,  292,  293,   38,
- /*  1170 */   295,   38,  165,  298,    0,   38,  249,   38,  303,  165,
- /*  1180 */     0,   38,  225,  256,    0,  256,   38,    0,   75,  110,
- /*  1190 */   148,  152,  151,  266,    0,    0,  144,  270,   53,    0,
- /*  1200 */   273,    0,    0,   87,  275,    0,  249,    0,    0,    0,
+ /*   840 */    99,   87,  101,  102,  103,  104,  105,  106,  270,   18,
+ /*   850 */   225,  270,  270,   79,   23,    0,   82,   79,    0,   21,
+ /*   860 */    82,    0,   38,  225,   72,   72,   35,  278,   76,   76,
+ /*   870 */     1,    2,   34,   38,  249,  184,  185,   22,   72,   48,
+ /*   880 */    22,  256,   76,   22,  226,  169,   72,  249,  219,   72,
+ /*   890 */    76,  266,   72,   76,  256,  270,   76,   72,  238,   72,
+ /*   900 */   275,   76,   72,   76,  266,   72,   76,  334,  270,   76,
+ /*   910 */   325,  259,  282,  288,  289,  290,  291,  292,  293,   72,
+ /*   920 */   295,   72,  319,   76,  228,   76,  288,  289,  290,  291,
+ /*   930 */   292,  293,  312,  295,  110,  287,  298,  249,   72,  314,
+ /*   940 */   302,  303,   76,  112,  225,  110,  328,   38,  315,   36,
+ /*   950 */    33,   72,  327,   36,   72,   76,  331,   20,   76,   42,
+ /*   960 */   231,   44,   45,   46,   47,  283,   57,  235,  249,   38,
+ /*   970 */   276,  231,  141,  142,  143,  256,  145,  231,  146,  264,
+ /*   980 */   121,  150,  134,  262,  262,  266,  231,   20,  280,  270,
+ /*   990 */   233,   74,  266,  162,   77,  164,  225,  166,  167,  168,
+ /*  1000 */    20,  274,  233,  256,   20,  267,  233,  288,  289,  290,
+ /*  1010 */   291,  292,  293,  233,  295,  231,  233,  298,   20,   19,
+ /*  1020 */   249,  302,  303,  227,  249,  249,  231,  256,  249,  227,
+ /*  1030 */   199,  249,   57,   33,  249,  249,   36,  266,  249,  249,
+ /*  1040 */   249,  270,   42,  249,   44,   45,   46,   47,  249,  230,
+ /*  1050 */   280,  225,  135,  155,  137,  274,  139,  270,  230,  288,
+ /*  1060 */   289,  290,  291,  292,  293,  294,  295,  296,  297,  266,
+ /*  1070 */   230,  256,  267,  156,   74,  249,  279,   77,   20,  207,
+ /*  1080 */   230,  271,  256,  324,  206,  287,  270,  324,  214,  271,
+ /*  1090 */   213,  270,  266,  270,  202,  201,  270,  198,  256,   20,
+ /*  1100 */   225,  221,  121,  335,  218,  216,  305,  107,  286,  321,
+ /*  1110 */    75,  270,  301,  270,  288,  289,  290,  291,  292,  293,
+ /*  1120 */   320,  295,  318,  271,  249,  317,  137,  271,  245,  256,
+ /*  1130 */   270,  256,  268,  230,  267,  230,  136,  330,  329,  139,
+ /*  1140 */   256,  266,   75,  252,  230,  270,  239,  231,  227,  281,
+ /*  1150 */   232,  243,  225,  277,  154,  243,  156,  223,  332,  333,
+ /*  1160 */   231,    0,    0,  288,  289,  290,  291,  292,  293,   64,
+ /*  1170 */   295,    0,   38,  298,  165,   38,  249,   38,  303,   38,
+ /*  1180 */   165,    0,  225,  256,   38,  256,   38,  165,    0,   38,
+ /*  1190 */     0,    0,   38,  266,   75,  152,  151,  270,  110,  148,
+ /*  1200 */   273,    0,    0,   53,  275,  144,  249,    0,    0,   87,
  /*  1210 */     0,    0,    0,  256,  121,  288,  289,  290,  291,  292,
  /*  1220 */   293,  292,  295,  266,    0,    0,    0,  270,    0,    0,
  /*  1230 */     0,    0,    0,  225,    0,    0,  307,  308,  309,    0,
  /*  1240 */   311,    0,    0,  314,    0,  288,  289,  290,  291,  292,
- /*  1250 */   293,    0,  295,    0,    0,   22,  327,  249,    0,    0,
- /*  1260 */   331,    0,    0,  225,  256,    0,    0,    0,    0,   51,
- /*  1270 */    43,    0,    0,    0,  266,   38,   36,    0,  270,   43,
- /*  1280 */     0,  273,   36,   38,   36,   38,   43,  249,   38,    0,
- /*  1290 */   333,  225,   43,   36,  256,   43,  288,  289,  290,  291,
- /*  1300 */   292,  293,    0,  295,  266,    0,    0,   84,  270,   22,
- /*  1310 */     0,    0,   38,   22,    0,  249,   38,   38,    0,   38,
- /*  1320 */    82,   38,  256,   38,   38,   22,  288,  289,  290,  291,
- /*  1330 */   292,  293,  266,  295,   38,  297,  270,   39,   22,  273,
- /*  1340 */   225,   72,   12,   13,    0,   38,   22,    0,   72,   22,
- /*  1350 */    22,   20,   22,    0,  288,  289,  290,  291,  292,  293,
- /*  1360 */   140,  295,    0,   38,  249,   38,  153,   22,   38,    0,
- /*  1370 */     0,  256,    0,   72,   75,   43,   72,   87,  225,  203,
- /*  1380 */    72,  266,  203,  197,   57,  270,  203,   57,  273,  225,
- /*  1390 */     4,   76,   75,  137,   75,  140,   76,   75,  135,   87,
- /*  1400 */   140,   72,  249,  288,  289,  290,  291,  292,  293,  256,
- /*  1410 */   295,   76,   75,  249,   72,   76,   76,   76,   72,  266,
- /*  1420 */   256,   87,   72,  270,    2,   98,   38,   38,   98,   38,
- /*  1430 */   266,   38,   38,   38,  270,   72,   76,  110,   87,  225,
- /*  1440 */   110,  288,  289,  290,  291,  292,  293,   76,  295,   75,
- /*  1450 */    75,  169,  288,  289,  290,  291,  292,  293,   76,  295,
- /*  1460 */    75,   22,   75,  249,   87,  171,   76,   75,    0,   43,
- /*  1470 */   256,  138,   76,   75,   75,  148,   75,   75,  148,   22,
- /*  1480 */   266,   75,   85,  135,  270,   76,   38,   87,   38,  225,
- /*  1490 */    87,   75,   38,   86,   76,   75,  169,  170,   38,  169,
- /*  1500 */   225,   76,  288,  289,  290,  291,  292,  293,   75,  295,
- /*  1510 */    76,   38,   75,  249,   76,   38,   75,  100,   22,  100,
- /*  1520 */   256,  100,   75,  100,  249,   38,   75,   75,   88,   38,
- /*  1530 */   266,  256,   22,   51,  270,   50,   38,  110,   57,   73,
- /*  1540 */    38,  266,   72,   38,   38,  270,   38,   38,  225,   38,
- /*  1550 */    38,   22,  288,  289,  290,  291,  292,  293,   57,  295,
+ /*  1250 */   293,    0,  295,    0,    0,    0,  327,  249,    0,    0,
+ /*  1260 */   331,    0,   22,  225,  256,    0,    0,    0,    0,    0,
+ /*  1270 */     0,    0,    0,    0,  266,   82,   43,    0,  270,    0,
+ /*  1280 */     0,  273,   36,   38,   36,   38,   43,  249,   51,    0,
+ /*  1290 */   333,  225,   43,   43,  256,   38,  288,  289,  290,  291,
+ /*  1300 */   292,  293,    0,  295,  266,   43,    0,    0,  270,    0,
+ /*  1310 */    36,    0,   22,    0,   38,  249,   38,   36,    0,   22,
+ /*  1320 */    84,   38,  256,   38,   72,   38,  288,  289,  290,  291,
+ /*  1330 */   292,  293,  266,  295,   38,  297,  270,   38,   38,  273,
+ /*  1340 */   225,   38,   12,   13,    0,    0,   22,   39,   22,   22,
+ /*  1350 */    38,    0,   22,   22,  288,  289,  290,  291,  292,  293,
+ /*  1360 */    72,  295,    0,   22,  249,   38,   20,    0,   38,    0,
+ /*  1370 */    38,  256,  153,    0,   22,  137,    0,    0,  225,   75,
+ /*  1380 */    43,  266,   72,  203,   57,  270,   72,   57,  273,  225,
+ /*  1390 */   203,   76,   72,   76,   75,  197,  140,   75,  135,  203,
+ /*  1400 */   140,   76,  249,  288,  289,  290,  291,  292,  293,  256,
+ /*  1410 */   295,   76,   72,  249,   75,   87,   87,   75,   38,  266,
+ /*  1420 */   256,   72,  140,  270,   76,   98,   72,   72,   98,   76,
+ /*  1430 */   266,   38,   38,   38,  270,   38,   38,  110,    2,  225,
+ /*  1440 */   110,  288,  289,  290,  291,  292,  293,   87,  295,   75,
+ /*  1450 */    72,   76,  288,  289,  290,  291,  292,  293,   76,  295,
+ /*  1460 */   169,   75,   75,  249,   76,   75,   87,   22,   87,  171,
+ /*  1470 */   256,   75,  138,    0,   75,  148,   76,   76,  148,   75,
+ /*  1480 */   266,   75,   43,   75,  270,  135,   75,   85,   22,  225,
+ /*  1490 */    87,   76,   38,   38,   87,   86,  169,  170,   75,  169,
+ /*  1500 */   225,   76,  288,  289,  290,  291,  292,  293,   38,  295,
+ /*  1510 */    75,   22,   38,  249,   76,   75,   38,   76,   75,   38,
+ /*  1520 */   256,  100,   76,   75,  249,   88,  100,  100,  100,   38,
+ /*  1530 */   266,  256,   75,   75,  270,   75,   38,   22,   51,  110,
+ /*  1540 */    50,  266,   38,   57,   73,  270,   38,   72,  225,   38,
+ /*  1550 */    38,   38,  288,  289,  290,  291,  292,  293,   38,  295,
  /*  1560 */    38,  225,    4,  288,  289,  290,  291,  292,  293,   38,
- /*  1570 */   295,   38,  249,   38,   38,   38,   38,   19,   38,  256,
- /*  1580 */     0,   38,   36,    0,   43,  249,   38,   36,   43,  266,
- /*  1590 */     0,   33,  256,  270,   36,   38,   36,   43,    0,   41,
- /*  1600 */    38,   36,  266,    0,   43,   47,  270,   38,   37,    0,
- /*  1610 */     0,  288,  289,  290,  291,  292,  293,   22,  295,   22,
- /*  1620 */    21,   20,   22,   21,  288,  289,  290,  291,  292,  293,
- /*  1630 */   225,  295,   74,  336,  336,   77,  336,  336,  336,  225,
+ /*  1570 */   295,   22,  249,   57,   38,   38,   38,   19,   38,  256,
+ /*  1580 */    38,   38,   38,   38,    0,  249,   38,   36,    0,  266,
+ /*  1590 */    43,   33,  256,  270,   36,   38,   36,   43,    0,   41,
+ /*  1600 */    38,   36,  266,    0,   43,   47,  270,   38,   36,   43,
+ /*  1610 */     0,  288,  289,  290,  291,  292,  293,   38,  295,   37,
+ /*  1620 */     0,    0,   22,   21,  288,  289,  290,  291,  292,  293,
+ /*  1630 */   225,  295,   74,   22,   22,   77,   21,   20,  336,  225,
  /*  1640 */   336,  336,  336,  336,  336,  336,  336,  336,  336,  336,
  /*  1650 */   336,  336,  336,  336,  249,  336,  336,  336,  336,  336,
  /*  1660 */   336,  256,  336,  249,  336,  336,  336,  336,  336,  336,
@@ -608,154 +608,154 @@ static const YYCODETYPE yy_lookahead[] = {
 };
 #define YY_SHIFT_COUNT    (571)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1610)
+#define YY_SHIFT_MAX      (1621)
 static const unsigned short int yy_shift_ofst[] = {
  /*     0 */   831,    0,   39,  214,  214,  214,  214,  253,  214,  214,
  /*    10 */   428,  467,  642,  467,  467,  467,  467,  467,  467,  467,
  /*    20 */   467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
- /*    30 */   467,  467,  467,  467,  467,  467,   71,   66,   66,   66,
- /*    40 */   133, 1330, 1330,  110,   38,   38,   62, 1330,   38,   38,
- /*    50 */    38,   38,   38,   38,   35,   38,  142,  208,   62,  298,
- /*    60 */   142,   38,   38,  142,   38,  142,  298,  142,  142,   38,
- /*    70 */   331,  217,  179,  393,  393,  389, 1327,  421,  187, 1327,
+ /*    30 */   467,  467,  467,  467,  467,  467,   71,  383,  383,  383,
+ /*    40 */   139, 1330, 1330,  110,   42,   42,   29, 1330,  348,   42,
+ /*    50 */    42,   42,   42,   42,   42,   52,   42,   98,  140,   29,
+ /*    60 */   142,   98,   42,   42,   98,   42,   98,  142,   98,   98,
+ /*    70 */    42,  193,  217,  179,  393,  393,  389, 1327,  421,  187,
  /*    80 */  1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
- /*    90 */  1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,  220,  327,
- /*   100 */   347,  347,  318,  318,  318,  500,  347,  347,  429,  298,
- /*   110 */   142,  298,  142,  473,  509,  741,  741,  741,  741,  741,
- /*   120 */   741,  741, 1000,  444,  564,  480,  111,  396,  120,   27,
- /*   130 */   663,  550,  518,  660,  518,  705,  592,  678,  777,  918,
- /*   140 */   911,  919,  814,  918,  918,  848,  837,  837,  918,  960,
- /*   150 */    35,  298,  964,   35,  429,  970,   35,   35,  918,   35,
- /*   160 */   984,  142,  142,  142,  142,  142,  142,  142,  142,  142,
- /*   170 */   142,  142,  918,  984,  969,  960,  331,  888,  298,  331,
- /*   180 */   964,  331,  429,  970,  331, 1037,  864,  870,  969,  864,
- /*   190 */   870,  969,  969,  874,  876,  885,  889,  893,  429, 1073,
- /*   200 */   973,  877,  883,  887, 1029,  142,  870,  969,  969,  870,
- /*   210 */   969,  972,  429,  970,  331,  473,  331,  429, 1058,  509,
- /*   220 */   918,  331,  984, 1960, 1960, 1960, 1960, 1960, 1960,  718,
- /*   230 */   917,  329, 1558,   47,  483,  503,  272,  280,  661,  734,
- /*   240 */    11,   11,   11,   11,   11,   11,   11,   11,  434,  505,
- /*   250 */   196,  409,  283,  283,  283,  283,  739,  301,  722,  713,
- /*   260 */   773,  774,  778,  118,  510,  861,  838,  645,  792,  793,
- /*   270 */   795,  884,  691,   29,  669,  801,  743,  808,  618,  817,
- /*   280 */   820,  825,  827,  833,  824,  832,  834,  835,  847,  849,
- /*   290 */   873,  879,  125,  897, 1150, 1151, 1089, 1155, 1119,  996,
- /*   300 */  1124, 1131, 1133, 1007, 1174, 1137, 1139, 1014, 1180, 1143,
- /*   310 */  1184, 1148, 1187, 1113, 1039, 1041, 1079, 1042, 1194, 1195,
- /*   320 */  1145, 1052, 1199, 1201, 1116, 1202, 1205, 1207, 1208, 1209,
- /*   330 */  1210, 1211, 1212, 1224, 1225, 1226, 1228, 1229, 1230, 1231,
- /*   340 */  1232, 1234, 1093, 1235, 1239, 1241, 1242, 1244, 1251, 1233,
- /*   350 */  1253, 1254, 1258, 1259, 1261, 1262, 1265, 1266, 1267, 1227,
- /*   360 */  1268, 1218, 1271, 1272, 1237, 1240, 1236, 1273, 1245, 1246,
- /*   370 */  1243, 1277, 1247, 1248, 1249, 1280, 1250, 1257, 1252, 1289,
- /*   380 */  1302, 1305, 1306, 1223, 1238, 1274, 1269, 1276, 1287, 1310,
- /*   390 */  1278, 1279, 1281, 1283, 1285, 1269, 1276, 1286, 1296, 1311,
- /*   400 */  1291, 1314, 1303, 1298, 1318, 1316, 1307, 1344, 1324, 1347,
- /*   410 */  1328, 1331, 1353, 1220, 1325, 1362, 1213, 1345, 1255, 1256,
- /*   420 */  1369, 1370, 1260, 1372, 1299, 1332, 1263, 1301, 1304, 1176,
- /*   430 */  1315, 1308, 1320, 1317, 1319, 1322, 1335, 1329, 1290, 1337,
- /*   440 */  1342, 1179, 1339, 1340, 1312, 1186, 1346, 1334, 1341, 1350,
- /*   450 */  1183, 1386, 1388, 1389, 1391, 1393, 1394, 1395, 1422, 1282,
- /*   460 */  1363, 1360, 1374, 1371, 1375, 1382, 1351, 1385, 1387, 1377,
- /*   470 */  1439, 1294, 1392, 1390, 1396, 1398, 1399, 1333, 1401, 1468,
- /*   480 */  1426, 1348, 1402, 1397, 1400, 1403, 1457, 1406, 1407, 1409,
- /*   490 */  1448, 1450, 1416, 1418, 1454, 1420, 1425, 1460, 1433, 1434,
- /*   500 */  1473, 1437, 1438, 1477, 1441, 1417, 1419, 1421, 1423, 1496,
- /*   510 */  1440, 1447, 1487, 1427, 1451, 1452, 1491, 1269, 1276, 1510,
- /*   520 */  1482, 1485, 1498, 1481, 1466, 1470, 1502, 1505, 1506, 1508,
- /*   530 */  1509, 1511, 1512, 1529, 1501, 1269, 1522, 1276, 1531, 1533,
- /*   540 */  1535, 1536, 1537, 1538, 1540, 1580, 1543, 1546, 1541, 1583,
- /*   550 */  1548, 1551, 1545, 1590, 1557, 1560, 1554, 1598, 1562, 1565,
- /*   560 */  1561, 1603, 1569, 1571, 1609, 1610, 1595, 1599, 1597, 1600,
- /*   570 */  1602, 1601,
+ /*    90 */  1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,  665,
+ /*   100 */   327,  109,  109,  360,  360,  360,  667,  109,  109,  312,
+ /*   110 */   142,   98,  142,   98,  422,  345,  741,  741,  741,  741,
+ /*   120 */   741,  741,  741, 1000,  444,  564,  480,  111,  396,  120,
+ /*   130 */    27,  681,  546,  597,  342,  597,  687,  478,  264,  777,
+ /*   140 */   937,  913,  931,  832,  937,  937,  859,  848,  848,  937,
+ /*   150 */   967,   52,  142,  980,   52,  312,  984,   52,   52,  937,
+ /*   160 */    52,  998,   98,   98,   98,   98,   98,   98,   98,   98,
+ /*   170 */    98,   98,   98,  937,  998,  975,  967,  193,  898,  142,
+ /*   180 */   193,  980,  193,  312,  984,  193, 1058,  872,  878,  975,
+ /*   190 */   872,  878,  975,  975,  874,  877,  892,  894,  899,  312,
+ /*   200 */  1079,  981,  880,  886,  889, 1035,   98,  878,  975,  975,
+ /*   210 */   878,  975,  989,  312,  984,  193,  422,  193,  312, 1067,
+ /*   220 */   345,  937,  193,  998, 1960, 1960, 1960, 1960, 1960, 1960,
+ /*   230 */   718,  917,  329, 1558,   47,  483,  503,  272,  280,  661,
+ /*   240 */   734,   11,   11,   11,   11,   11,   11,   11,   11,   94,
+ /*   250 */   505,  196,  409,  283,  283,  283,  283,  595,  571,  373,
+ /*   260 */   547,  657,  774,  778,  855,  858,  861,  838,  645,  737,
+ /*   270 */   792,  793,  869,  691,  332,  669,  806,  716,  814,  754,
+ /*   280 */   817,  820,  825,  827,  830,  824,  835,  833,  847,  849,
+ /*   290 */   866,  879,  882,  125,  909, 1161, 1162, 1105, 1171, 1134,
+ /*   300 */  1009, 1137, 1139, 1141, 1015, 1181, 1146, 1148, 1022, 1188,
+ /*   310 */  1151, 1190, 1154, 1191, 1119, 1043, 1045, 1088, 1051, 1201,
+ /*   320 */  1202, 1150, 1061, 1207, 1208, 1122, 1210, 1211, 1212, 1224,
+ /*   330 */  1225, 1226, 1228, 1229, 1230, 1231, 1232, 1234, 1235, 1239,
+ /*   340 */  1241, 1242, 1244, 1093, 1251, 1253, 1254, 1255, 1258, 1259,
+ /*   350 */  1240, 1261, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272,
+ /*   360 */  1233, 1273, 1237, 1277, 1279, 1245, 1246, 1243, 1280, 1247,
+ /*   370 */  1248, 1249, 1289, 1257, 1274, 1250, 1302, 1278, 1281, 1262,
+ /*   380 */  1306, 1307, 1309, 1311, 1236, 1193, 1276, 1252, 1288, 1290,
+ /*   390 */  1313, 1283, 1285, 1287, 1296, 1299, 1252, 1288, 1300, 1303,
+ /*   400 */  1318, 1297, 1344, 1324, 1308, 1345, 1326, 1312, 1351, 1331,
+ /*   410 */  1362, 1341, 1346, 1367, 1256, 1332, 1369, 1219, 1352, 1260,
+ /*   420 */  1238, 1373, 1376, 1282, 1377, 1304, 1337, 1263, 1310, 1314,
+ /*   430 */  1180, 1315, 1320, 1317, 1319, 1322, 1339, 1325, 1340, 1328,
+ /*   440 */  1342, 1349, 1187, 1335, 1348, 1329, 1198, 1354, 1360, 1353,
+ /*   450 */  1355, 1196, 1380, 1393, 1394, 1395, 1397, 1398, 1436, 1291,
+ /*   460 */  1378, 1375, 1374, 1382, 1386, 1388, 1379, 1387, 1390, 1381,
+ /*   470 */  1445, 1298, 1396, 1400, 1401, 1399, 1404, 1334, 1406, 1473,
+ /*   480 */  1439, 1350, 1408, 1402, 1403, 1407, 1466, 1411, 1409, 1415,
+ /*   490 */  1454, 1455, 1423, 1425, 1470, 1435, 1438, 1474, 1440, 1441,
+ /*   500 */  1478, 1443, 1446, 1481, 1448, 1421, 1426, 1427, 1428, 1489,
+ /*   510 */  1437, 1457, 1491, 1429, 1458, 1460, 1498, 1252, 1288, 1515,
+ /*   520 */  1487, 1490, 1504, 1486, 1471, 1475, 1508, 1511, 1512, 1513,
+ /*   530 */  1520, 1522, 1531, 1549, 1516, 1252, 1536, 1288, 1537, 1538,
+ /*   540 */  1540, 1542, 1543, 1544, 1545, 1584, 1548, 1551, 1547, 1588,
+ /*   550 */  1557, 1560, 1554, 1598, 1562, 1565, 1561, 1603, 1569, 1572,
+ /*   560 */  1566, 1610, 1579, 1582, 1620, 1621, 1600, 1602, 1611, 1612,
+ /*   570 */  1615, 1617,
 };
-#define YY_REDUCE_COUNT (228)
-#define YY_REDUCE_MIN   (-263)
+#define YY_REDUCE_COUNT (229)
+#define YY_REDUCE_MIN   (-273)
 #define YY_REDUCE_MAX   (1664)
 static const short yy_reduce_ofst[] = {
  /*     0 */  -212, -210, -159,  368,   13,  265,  440,  625,  638,  719,
  /*    10 */   771,  826,  875,  927, -221,  957, 1008, 1038, 1066, 1115,
  /*    20 */  1153, 1164, 1214, 1264, 1275, 1323, 1336, 1405, 1414, 1464,
  /*    30 */  1514, 1525, 1573, 1586, 1655, 1664,  929, -183, -104,  453,
- /*    40 */  -125, -253, -251, -211, -226,  266,   50, -241, -118,  -89,
- /*    50 */   222,  267,  294,  306, -192,  438,  -59, -248,   51, -263,
- /*    60 */   206,  448,  471,   -6,  481,  210, -171,  281,  271,  452,
- /*    70 */   -83, -224, -200, -200, -200, -208,   82,  -88, -198,  154,
+ /*    40 */  -125, -253, -251, -211, -226,  266,   50, -241, -273, -118,
+ /*    50 */   -89,  222,  267,  294,  306,  -93,  438,  -59, -248,   51,
+ /*    60 */  -263,  206,  448,  471,   -6,  481,  210, -171,  281,  271,
+ /*    70 */   452,   16, -224, -200, -200, -200, -208,  154,   59, -198,
  /*    80 */   221,  263,  304,  398,  456,  488,  489,  495,  497,  498,
- /*    90 */   499,  526,  529,  530,  532,  538,  578,  581,  174, -178,
- /*   100 */    32,  176,  -10,    4,  289,  322,  397,  451,  -97,  188,
- /*   110 */   290,  432,  291,  -12,  392, -239,  376,  417,  445,  457,
- /*   120 */   484,  486,  478,  540,  571,  479,  504,  582,  600,  579,
- /*   130 */   662,  615,  610,  610,  610,  675,  604,  622,  675,  715,
- /*   140 */   665,  723,  689,  735,  736,  706,  716,  717,  746,  702,
- /*   150 */   750,  720,  714,  754,  744,  725,  768,  769,  772,  780,
- /*   160 */   779,  756,  766,  767,  775,  776,  782,  783,  785,  786,
- /*   170 */   789,  790,  787,  796,  758,  749,  810,  770,  784,  818,
- /*   180 */   781,  823,  802,  803,  839,  791,  748,  809,  811,  755,
- /*   190 */   812,  815,  816,  763,  788,  794,  805,  610,  841,  813,
- /*   200 */   797,  760,  798,  800,  804,  675,  840,  836,  843,  852,
- /*   210 */   850,  842,  869,  859,  900,  882,  902,  878,  886,  896,
- /*   220 */   906,  910,  915,  866,  863,  903,  904,  916,  926,
+ /*    90 */   499,  526,  529,  530,  532,  538,  578,  581,  582,  183,
+ /*   100 */  -178,  275,  316,  -10,    4,  289,   10,  397,  462,  276,
+ /*   110 */   188,  433,  527,  310,  -12, -153, -239,  323,  445,  475,
+ /*   120 */   506,  525,  548,  589,  658,  660,  573,  585,  652,  630,
+ /*   130 */   603,  696,  648,  620,  620,  620,  688,  618,  633,  688,
+ /*   140 */   729,  682,  732,  694,  740,  746,  715,  721,  722,  755,
+ /*   150 */   708,  757,  726,  727,  769,  747,  738,  773,  780,  784,
+ /*   160 */   783,  796,  775,  776,  779,  782,  785,  786,  789,  790,
+ /*   170 */   791,  794,  799,  795,  802,  787,  770,  819,  797,  803,
+ /*   180 */   828,  781,  840,  815,  805,  850,  798,  759,  810,  816,
+ /*   190 */   763,  818,  821,  823,  788,  800,  804,  808,  620,  842,
+ /*   200 */   822,  801,  768,  807,  809,  811,  688,  852,  841,  843,
+ /*   210 */   856,  860,  864,  873,  867,  903,  883,  905,  884,  891,
+ /*   220 */   907,  916,  914,  921,  876,  868,  908,  912,  918,  934,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    10 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    20 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    30 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    40 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    50 */  1285, 1285, 1285, 1285, 1344, 1285, 1285, 1285, 1285, 1285,
- /*    60 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    70 */  1342, 1487, 1285, 1643, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    80 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*    90 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1344,
- /*   100 */  1285, 1285, 1654, 1654, 1654, 1342, 1285, 1285, 1285, 1285,
- /*   110 */  1285, 1285, 1285, 1439, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   120 */  1285, 1285, 1521, 1285, 1285, 1718, 1285, 1392, 1527, 1678,
- /*   130 */  1285, 1670, 1646, 1660, 1647, 1285, 1703, 1663, 1285, 1285,
- /*   140 */  1285, 1285, 1513, 1285, 1285, 1492, 1489, 1489, 1285, 1285,
- /*   150 */  1344, 1285, 1285, 1344, 1285, 1285, 1344, 1344, 1285, 1344,
- /*   160 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   170 */  1285, 1285, 1285, 1285, 1285, 1285, 1342, 1523, 1285, 1342,
- /*   180 */  1285, 1342, 1285, 1285, 1342, 1285, 1685, 1683, 1285, 1685,
- /*   190 */  1683, 1285, 1285, 1697, 1693, 1676, 1674, 1660, 1285, 1285,
- /*   200 */  1285, 1721, 1709, 1705, 1285, 1285, 1683, 1285, 1285, 1683,
- /*   210 */  1285, 1500, 1285, 1285, 1342, 1285, 1342, 1285, 1408, 1285,
- /*   220 */  1285, 1342, 1285, 1515, 1529, 1442, 1442, 1345, 1290, 1285,
- /*   230 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   240 */  1590, 1696, 1695, 1619, 1618, 1617, 1615, 1589, 1285, 1285,
- /*   250 */  1285, 1285, 1583, 1584, 1582, 1581, 1285, 1285, 1285, 1285,
- /*   260 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   270 */  1285, 1644, 1285, 1706, 1710, 1285, 1285, 1285, 1567, 1285,
- /*   280 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   290 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   300 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   310 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   320 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   330 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   340 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   350 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   360 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   370 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   380 */  1285, 1285, 1285, 1285, 1285, 1285, 1455, 1454, 1285, 1285,
- /*   390 */  1285, 1285, 1285, 1285, 1285, 1372, 1371, 1285, 1285, 1285,
- /*   400 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   410 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   420 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1667, 1677, 1285,
- /*   430 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1567, 1285,
- /*   440 */  1694, 1285, 1653, 1649, 1285, 1285, 1645, 1285, 1285, 1704,
- /*   450 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1639, 1285,
- /*   460 */  1612, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   470 */  1285, 1577, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   480 */  1285, 1285, 1285, 1285, 1566, 1285, 1285, 1285, 1285, 1285,
- /*   490 */  1285, 1285, 1436, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   500 */  1285, 1285, 1285, 1285, 1285, 1421, 1419, 1418, 1417, 1285,
- /*   510 */  1414, 1285, 1285, 1285, 1285, 1285, 1285, 1445, 1444, 1285,
- /*   520 */  1285, 1285, 1285, 1285, 1285, 1365, 1285, 1285, 1285, 1285,
- /*   530 */  1285, 1285, 1285, 1285, 1285, 1356, 1285, 1355, 1285, 1285,
- /*   540 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   550 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   560 */  1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
- /*   570 */  1285, 1285,
+ /*     0 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    10 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    20 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    30 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    40 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    50 */  1287, 1287, 1287, 1287, 1287, 1346, 1287, 1287, 1287, 1287,
+ /*    60 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    70 */  1287, 1344, 1489, 1287, 1645, 1287, 1287, 1287, 1287, 1287,
+ /*    80 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*    90 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   100 */  1346, 1287, 1287, 1656, 1656, 1656, 1344, 1287, 1287, 1287,
+ /*   110 */  1287, 1287, 1287, 1287, 1441, 1287, 1287, 1287, 1287, 1287,
+ /*   120 */  1287, 1287, 1287, 1523, 1287, 1287, 1721, 1287, 1394, 1529,
+ /*   130 */  1680, 1287, 1672, 1648, 1662, 1649, 1287, 1706, 1665, 1287,
+ /*   140 */  1287, 1287, 1287, 1515, 1287, 1287, 1494, 1491, 1491, 1287,
+ /*   150 */  1287, 1346, 1287, 1287, 1346, 1287, 1287, 1346, 1346, 1287,
+ /*   160 */  1346, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   170 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1344, 1525, 1287,
+ /*   180 */  1344, 1287, 1344, 1287, 1287, 1344, 1287, 1687, 1685, 1287,
+ /*   190 */  1687, 1685, 1287, 1287, 1699, 1695, 1678, 1676, 1662, 1287,
+ /*   200 */  1287, 1287, 1724, 1712, 1708, 1287, 1287, 1685, 1287, 1287,
+ /*   210 */  1685, 1287, 1502, 1287, 1287, 1344, 1287, 1344, 1287, 1410,
+ /*   220 */  1287, 1287, 1344, 1287, 1517, 1531, 1444, 1444, 1347, 1292,
+ /*   230 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   240 */  1287, 1592, 1698, 1697, 1621, 1620, 1619, 1617, 1591, 1287,
+ /*   250 */  1287, 1287, 1287, 1585, 1586, 1584, 1583, 1287, 1287, 1287,
+ /*   260 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   270 */  1287, 1287, 1646, 1287, 1709, 1713, 1287, 1287, 1287, 1569,
+ /*   280 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   290 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   300 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   310 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   320 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   330 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   340 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   350 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   360 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   370 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   380 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1457, 1456, 1287,
+ /*   390 */  1287, 1287, 1287, 1287, 1287, 1287, 1374, 1373, 1287, 1287,
+ /*   400 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   410 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   420 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1669, 1679,
+ /*   430 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1569,
+ /*   440 */  1287, 1696, 1287, 1655, 1651, 1287, 1287, 1647, 1287, 1287,
+ /*   450 */  1707, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1641, 1287,
+ /*   460 */  1614, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   470 */  1287, 1579, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   480 */  1287, 1287, 1287, 1287, 1568, 1287, 1287, 1287, 1287, 1287,
+ /*   490 */  1287, 1287, 1438, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   500 */  1287, 1287, 1287, 1287, 1287, 1423, 1421, 1420, 1419, 1287,
+ /*   510 */  1416, 1287, 1287, 1287, 1287, 1287, 1287, 1447, 1446, 1287,
+ /*   520 */  1287, 1287, 1287, 1287, 1287, 1367, 1287, 1287, 1287, 1287,
+ /*   530 */  1287, 1287, 1287, 1287, 1287, 1358, 1287, 1357, 1287, 1287,
+ /*   540 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   550 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   560 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
+ /*   570 */  1287, 1287,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1619,28 +1619,29 @@ static const char *const yyRuleName[] = {
  /* 411 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
  /* 412 */ "query_expression_body ::= query_primary",
  /* 413 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
- /* 414 */ "query_primary ::= query_specification",
- /* 415 */ "order_by_clause_opt ::=",
- /* 416 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 417 */ "slimit_clause_opt ::=",
- /* 418 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 419 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 420 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 421 */ "limit_clause_opt ::=",
- /* 422 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 423 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 424 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 425 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 426 */ "search_condition ::= common_expression",
- /* 427 */ "sort_specification_list ::= sort_specification",
- /* 428 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 429 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
- /* 430 */ "ordering_specification_opt ::=",
- /* 431 */ "ordering_specification_opt ::= ASC",
- /* 432 */ "ordering_specification_opt ::= DESC",
- /* 433 */ "null_ordering_opt ::=",
- /* 434 */ "null_ordering_opt ::= NULLS FIRST",
- /* 435 */ "null_ordering_opt ::= NULLS LAST",
+ /* 414 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
+ /* 415 */ "query_primary ::= query_specification",
+ /* 416 */ "order_by_clause_opt ::=",
+ /* 417 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 418 */ "slimit_clause_opt ::=",
+ /* 419 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 420 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 421 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 422 */ "limit_clause_opt ::=",
+ /* 423 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 424 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 425 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 426 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 427 */ "search_condition ::= common_expression",
+ /* 428 */ "sort_specification_list ::= sort_specification",
+ /* 429 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 430 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
+ /* 431 */ "ordering_specification_opt ::=",
+ /* 432 */ "ordering_specification_opt ::= ASC",
+ /* 433 */ "ordering_specification_opt ::= DESC",
+ /* 434 */ "null_ordering_opt ::=",
+ /* 435 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 436 */ "null_ordering_opt ::= NULLS LAST",
 };
 #endif /* NDEBUG */
 
@@ -2637,28 +2638,29 @@ static const struct {
   {  275,   -4 }, /* (411) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
   {  327,   -1 }, /* (412) query_expression_body ::= query_primary */
   {  327,   -4 }, /* (413) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  331,   -1 }, /* (414) query_primary ::= query_specification */
-  {  328,    0 }, /* (415) order_by_clause_opt ::= */
-  {  328,   -3 }, /* (416) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  329,    0 }, /* (417) slimit_clause_opt ::= */
-  {  329,   -2 }, /* (418) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  329,   -4 }, /* (419) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  329,   -4 }, /* (420) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  330,    0 }, /* (421) limit_clause_opt ::= */
-  {  330,   -2 }, /* (422) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  330,   -4 }, /* (423) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  330,   -4 }, /* (424) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  292,   -3 }, /* (425) subquery ::= NK_LP query_expression NK_RP */
-  {  313,   -1 }, /* (426) search_condition ::= common_expression */
-  {  332,   -1 }, /* (427) sort_specification_list ::= sort_specification */
-  {  332,   -3 }, /* (428) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  333,   -3 }, /* (429) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  334,    0 }, /* (430) ordering_specification_opt ::= */
-  {  334,   -1 }, /* (431) ordering_specification_opt ::= ASC */
-  {  334,   -1 }, /* (432) ordering_specification_opt ::= DESC */
-  {  335,    0 }, /* (433) null_ordering_opt ::= */
-  {  335,   -2 }, /* (434) null_ordering_opt ::= NULLS FIRST */
-  {  335,   -2 }, /* (435) null_ordering_opt ::= NULLS LAST */
+  {  327,   -3 }, /* (414) query_expression_body ::= query_expression_body UNION query_expression_body */
+  {  331,   -1 }, /* (415) query_primary ::= query_specification */
+  {  328,    0 }, /* (416) order_by_clause_opt ::= */
+  {  328,   -3 }, /* (417) order_by_clause_opt ::= ORDER BY sort_specification_list */
+  {  329,    0 }, /* (418) slimit_clause_opt ::= */
+  {  329,   -2 }, /* (419) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+  {  329,   -4 }, /* (420) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+  {  329,   -4 }, /* (421) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  330,    0 }, /* (422) limit_clause_opt ::= */
+  {  330,   -2 }, /* (423) limit_clause_opt ::= LIMIT NK_INTEGER */
+  {  330,   -4 }, /* (424) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+  {  330,   -4 }, /* (425) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  292,   -3 }, /* (426) subquery ::= NK_LP query_expression NK_RP */
+  {  313,   -1 }, /* (427) search_condition ::= common_expression */
+  {  332,   -1 }, /* (428) sort_specification_list ::= sort_specification */
+  {  332,   -3 }, /* (429) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+  {  333,   -3 }, /* (430) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+  {  334,    0 }, /* (431) ordering_specification_opt ::= */
+  {  334,   -1 }, /* (432) ordering_specification_opt ::= ASC */
+  {  334,   -1 }, /* (433) ordering_specification_opt ::= DESC */
+  {  335,    0 }, /* (434) null_ordering_opt ::= */
+  {  335,   -2 }, /* (435) null_ordering_opt ::= NULLS FIRST */
+  {  335,   -2 }, /* (436) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -3052,7 +3054,7 @@ static YYACTIONTYPE yy_reduce(
       case 275: /* literal_list ::= signed_literal */ yytestcase(yyruleno==275);
       case 325: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==325);
       case 380: /* select_sublist ::= select_item */ yytestcase(yyruleno==380);
-      case 427: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==427);
+      case 428: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==428);
 { yylhsminor.yy376 = createNodeList(pCxt, yymsp[0].minor.yy392); }
   yymsp[0].minor.yy376 = yylhsminor.yy376;
         break;
@@ -3064,7 +3066,7 @@ static YYACTIONTYPE yy_reduce(
       case 276: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==276);
       case 326: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==326);
       case 381: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==381);
-      case 428: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==428);
+      case 429: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==429);
 { yylhsminor.yy376 = addNodeToList(pCxt, yymsp[-2].minor.yy376, yymsp[0].minor.yy392); }
   yymsp[-2].minor.yy376 = yylhsminor.yy376;
         break;
@@ -3147,7 +3149,7 @@ static YYACTIONTYPE yy_reduce(
       case 151: /* tags_def_opt ::= */ yytestcase(yyruleno==151);
       case 388: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==388);
       case 405: /* group_by_clause_opt ::= */ yytestcase(yyruleno==405);
-      case 415: /* order_by_clause_opt ::= */ yytestcase(yyruleno==415);
+      case 416: /* order_by_clause_opt ::= */ yytestcase(yyruleno==416);
 { yymsp[1].minor.yy376 = NULL; }
         break;
       case 121: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */
@@ -3394,8 +3396,8 @@ static YYACTIONTYPE yy_reduce(
       case 395: /* sliding_opt ::= */ yytestcase(yyruleno==395);
       case 397: /* fill_opt ::= */ yytestcase(yyruleno==397);
       case 409: /* having_clause_opt ::= */ yytestcase(yyruleno==409);
-      case 417: /* slimit_clause_opt ::= */ yytestcase(yyruleno==417);
-      case 421: /* limit_clause_opt ::= */ yytestcase(yyruleno==421);
+      case 418: /* slimit_clause_opt ::= */ yytestcase(yyruleno==418);
+      case 422: /* limit_clause_opt ::= */ yytestcase(yyruleno==422);
 { yymsp[1].minor.yy392 = NULL; }
         break;
       case 202: /* like_pattern_opt ::= LIKE NK_STRING */
@@ -3565,7 +3567,7 @@ static YYACTIONTYPE yy_reduce(
       case 361: /* table_reference ::= joined_table */ yytestcase(yyruleno==361);
       case 365: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==365);
       case 412: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==412);
-      case 414: /* query_primary ::= query_specification */ yytestcase(yyruleno==414);
+      case 415: /* query_primary ::= query_specification */ yytestcase(yyruleno==415);
 { yylhsminor.yy392 = yymsp[0].minor.yy392; }
   yymsp[0].minor.yy392 = yylhsminor.yy392;
         break;
@@ -3625,7 +3627,7 @@ static YYACTIONTYPE yy_reduce(
       case 273: /* signed_literal ::= duration_literal */
       case 327: /* star_func_para ::= expression */ yytestcase(yyruleno==327);
       case 382: /* select_item ::= common_expression */ yytestcase(yyruleno==382);
-      case 426: /* search_condition ::= common_expression */ yytestcase(yyruleno==426);
+      case 427: /* search_condition ::= common_expression */ yytestcase(yyruleno==427);
 { yylhsminor.yy392 = releaseRawExprNode(pCxt, yymsp[0].minor.yy392); }
   yymsp[0].minor.yy392 = yylhsminor.yy392;
         break;
@@ -3917,7 +3919,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 389: /* partition_by_clause_opt ::= PARTITION BY expression_list */
       case 406: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==406);
-      case 416: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==416);
+      case 417: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==417);
 { yymsp[-2].minor.yy376 = yymsp[0].minor.yy376; }
         break;
       case 391: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
@@ -3976,42 +3978,46 @@ static YYACTIONTYPE yy_reduce(
 { yylhsminor.yy392 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy392, yymsp[0].minor.yy392); }
   yymsp[-3].minor.yy392 = yylhsminor.yy392;
         break;
-      case 418: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
-      case 422: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==422);
+      case 414: /* query_expression_body ::= query_expression_body UNION query_expression_body */
+{ yylhsminor.yy392 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy392, yymsp[0].minor.yy392); }
+  yymsp[-2].minor.yy392 = yylhsminor.yy392;
+        break;
+      case 419: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+      case 423: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==423);
 { yymsp[-1].minor.yy392 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
         break;
-      case 419: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-      case 423: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==423);
+      case 420: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 424: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==424);
 { yymsp[-3].minor.yy392 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
         break;
-      case 420: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-      case 424: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==424);
+      case 421: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 425: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==425);
 { yymsp[-3].minor.yy392 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
         break;
-      case 425: /* subquery ::= NK_LP query_expression NK_RP */
+      case 426: /* subquery ::= NK_LP query_expression NK_RP */
 { yylhsminor.yy392 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy392); }
   yymsp[-2].minor.yy392 = yylhsminor.yy392;
         break;
-      case 429: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+      case 430: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
 { yylhsminor.yy392 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy392), yymsp[-1].minor.yy386, yymsp[0].minor.yy361); }
   yymsp[-2].minor.yy392 = yylhsminor.yy392;
         break;
-      case 430: /* ordering_specification_opt ::= */
+      case 431: /* ordering_specification_opt ::= */
 { yymsp[1].minor.yy386 = ORDER_ASC; }
         break;
-      case 431: /* ordering_specification_opt ::= ASC */
+      case 432: /* ordering_specification_opt ::= ASC */
 { yymsp[0].minor.yy386 = ORDER_ASC; }
         break;
-      case 432: /* ordering_specification_opt ::= DESC */
+      case 433: /* ordering_specification_opt ::= DESC */
 { yymsp[0].minor.yy386 = ORDER_DESC; }
         break;
-      case 433: /* null_ordering_opt ::= */
+      case 434: /* null_ordering_opt ::= */
 { yymsp[1].minor.yy361 = NULL_ORDER_DEFAULT; }
         break;
-      case 434: /* null_ordering_opt ::= NULLS FIRST */
+      case 435: /* null_ordering_opt ::= NULLS FIRST */
 { yymsp[-1].minor.yy361 = NULL_ORDER_FIRST; }
         break;
-      case 435: /* null_ordering_opt ::= NULLS LAST */
+      case 436: /* null_ordering_opt ::= NULLS LAST */
 { yymsp[-1].minor.yy361 = NULL_ORDER_LAST; }
         break;
       default:
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index 78adea15ce..b13c0a8888 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -22,6 +22,7 @@ typedef struct SLogicPlanContext {
 } SLogicPlanContext;
 
 typedef int32_t (*FCreateLogicNode)(SLogicPlanContext*, SSelectStmt*, SLogicNode**);
+typedef int32_t (*FCreateSetOpLogicNode)(SLogicPlanContext*, SSetOperator*, SLogicNode**);
 
 static int32_t doCreateLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SNode* pTable, SLogicNode** pLogicNode);
 static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogicNode** pLogicNode);
@@ -84,13 +85,19 @@ static EDealRes doNameExpr(SNode* pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static int32_t rewriteExpr(SNodeList* pExprs, SSelectStmt* pSelect, ESqlClause clause) {
+static int32_t rewriteExprForSelect(SNodeList* pExprs, SSelectStmt* pSelect, ESqlClause clause) {
   nodesWalkExprs(pExprs, doNameExpr, NULL);
   SRewriteExprCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pExprs = pExprs };
   nodesRewriteSelectStmt(pSelect, clause, doRewriteExpr, &cxt);
   return cxt.errCode;
 }
 
+static int32_t rewriteExprs(SNodeList* pExprs, SNodeList* pTarget) {
+  SRewriteExprCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pExprs = pExprs };
+  nodesRewriteExprs(pTarget, doRewriteExpr, &cxt);
+  return cxt.errCode;
+}
+
 static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLogicNode* pNewRoot) {
   if (NULL == pNewRoot->pChildren) {
     pNewRoot->pChildren = nodesMakeList();
@@ -343,7 +350,9 @@ static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr)
   }
   pCol->node.resType = pExpr->resType;
   strcpy(pCol->colName, pExpr->aliasName);
-  strcpy(pCol->tableAlias, pStmtName);
+  if (NULL != pStmtName) {
+    strcpy(pCol->tableAlias, pStmtName);
+  }
   return pCol;
 }
 
@@ -430,10 +439,10 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
 
   // rewrite the expression in subsequent clauses
   if (TSDB_CODE_SUCCESS == code) {
-    code = rewriteExpr(pAgg->pGroupKeys, pSelect, SQL_CLAUSE_GROUP_BY);
+    code = rewriteExprForSelect(pAgg->pGroupKeys, pSelect, SQL_CLAUSE_GROUP_BY);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = rewriteExpr(pAgg->pAggFuncs, pSelect, SQL_CLAUSE_GROUP_BY);
+    code = rewriteExprForSelect(pAgg->pAggFuncs, pSelect, SQL_CLAUSE_GROUP_BY);
   }
 
   if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) {
@@ -469,7 +478,7 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm
   }
 
   if (TSDB_CODE_SUCCESS == code) {
-    code = rewriteExpr(pWindow->pFuncs, pSelect, SQL_CLAUSE_WINDOW);
+    code = rewriteExprForSelect(pWindow->pFuncs, pSelect, SQL_CLAUSE_WINDOW);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -720,7 +729,7 @@ static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
 
   // rewrite the expression in subsequent clauses
   if (TSDB_CODE_SUCCESS == code) {
-    code = rewriteExpr(pAgg->pGroupKeys, pSelect, SQL_CLAUSE_DISTINCT);
+    code = rewriteExprForSelect(pAgg->pGroupKeys, pSelect, SQL_CLAUSE_DISTINCT);
   }
 
   // set the output
@@ -768,11 +777,160 @@ static int32_t createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSele
   return code;
 }
 
+static int32_t createSetOpChildLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, FCreateSetOpLogicNode func, SLogicNode** pRoot) {
+  SLogicNode* pNode = NULL;
+  int32_t code = func(pCxt, pSetOperator, &pNode);
+  if (TSDB_CODE_SUCCESS == code && NULL != pNode) {
+    code = pushLogicNode(pCxt, pRoot, pNode);
+  }
+  if (TSDB_CODE_SUCCESS != code) {
+    nodesDestroyNode(pNode);
+  }
+  return code;
+}
+
+static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
+  if (NULL == pSetOperator->pOrderByList) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSortLogicNode* pSort = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT);
+  if (NULL == pSort) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  pSort->node.pTargets = nodesCloneList(pSetOperator->pProjectionList);
+  if (NULL == pSort->node.pTargets) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    pSort->pSortKeys = nodesCloneList(pSetOperator->pOrderByList);
+    if (NULL == pSort->pSortKeys) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = (SLogicNode*)pSort;
+  } else {
+    nodesDestroyNode(pSort);
+  }
+
+  return code;
+}
+
+static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
+  SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT);
+  if (NULL == pProject) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (NULL != pSetOperator->pLimit) {
+    pProject->limit = ((SLimitNode*)pSetOperator->pLimit)->limit;
+    pProject->offset = ((SLimitNode*)pSetOperator->pLimit)->offset;
+  } else {
+    pProject->limit = -1;
+    pProject->offset = -1;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  pProject->pProjections = nodesCloneList(pSetOperator->pProjectionList);
+  if (NULL == pProject->pProjections) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createColumnByProjections(pCxt, NULL, pSetOperator->pProjectionList, &pProject->node.pTargets);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = (SLogicNode*)pProject;
+  } else {
+    nodesDestroyNode(pProject);
+  }
+
+  return code;
+}
+
+static int32_t createSetOpAggLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
+  SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG);
+  if (NULL == pAgg) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  pAgg->pGroupKeys = nodesCloneList(pSetOperator->pProjectionList);
+  if (NULL == pAgg->pGroupKeys) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  // rewrite the expression in subsequent clauses
+  if (TSDB_CODE_SUCCESS == code) {
+    code = rewriteExprs(pAgg->pGroupKeys, pSetOperator->pOrderByList);
+  }
+
+  // set the output
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createColumnByRewriteExps(pCxt, pAgg->pGroupKeys, &pAgg->node.pTargets);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = (SLogicNode*)pAgg;
+  } else {
+    nodesDestroyNode(pAgg);
+  }
+
+  return code;
+}
+
+static int32_t createSetOpLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
+  SLogicNode* pSetOp = NULL;
+  int32_t code = TSDB_CODE_SUCCESS;
+  switch (pSetOperator->opType) {
+    case SET_OP_TYPE_UNION_ALL:
+      code = createSetOpProjectLogicNode(pCxt, pSetOperator, &pSetOp);
+      break;
+    case SET_OP_TYPE_UNION:
+      code = createSetOpAggLogicNode(pCxt, pSetOperator, &pSetOp);
+      break;
+    default:
+      code = -1;
+      break;
+  }
+
+  SLogicNode* pLeft = NULL;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createQueryLogicNode(pCxt, pSetOperator->pLeft, &pLeft);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesListMakeStrictAppend(&pSetOp->pChildren, (SNode*)pLeft);
+  }
+  SLogicNode* pRight = NULL;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createQueryLogicNode(pCxt, pSetOperator->pRight, &pRight);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesListStrictAppend(pSetOp->pChildren, (SNode*)pRight);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = (SLogicNode*)pSetOp;
+  } else {
+    nodesDestroyNode(pSetOp);
+  }
+
+  return code;
+}
+
 static int32_t createSetOperatorLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
   SLogicNode* pRoot = NULL;
-  int32_t code = createQueryLogicNode(pCxt, pSetOperator->pLeft, &pRoot);
+  int32_t code = createSetOpLogicNode(pCxt, pSetOperator, &pRoot);
   if (TSDB_CODE_SUCCESS == code) {
-    code = createQueryLogicNode(pCxt, pSetOperator->pRight, &pRoot);
+    code = createSetOpChildLogicNode(pCxt, pSetOperator, createSetOpSortLogicNode, &pRoot);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index caeab20970..745029730f 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -38,7 +38,7 @@ typedef struct SPhysiPlanContext {
 static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char* pKey) {
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     SColumnNode* pCol = (SColumnNode*)pNode;
-    if (NULL != pStmtName) {
+    if (NULL != pStmtName && '\0' != pStmtName[0]) {
       return sprintf(pKey, "%s.%s", pStmtName, pCol->node.aliasName);
     }
     if ('\0' == pCol->tableAlias[0]) {
@@ -47,7 +47,7 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char* pKey) {
     return sprintf(pKey, "%s.%s", pCol->tableAlias, pCol->colName);
   }
 
-  if (NULL != pStmtName) {
+  if (NULL != pStmtName && '\0' != pStmtName[0]) {
     return sprintf(pKey, "%s.%s", pStmtName, ((SExprNode*)pNode)->aliasName);
   }
   return sprintf(pKey, "%s", ((SExprNode*)pNode)->aliasName);
diff --git a/source/libs/planner/src/planScaleOut.c b/source/libs/planner/src/planScaleOut.c
index 2b5fd12e22..7bb97b59d7 100644
--- a/source/libs/planner/src/planScaleOut.c
+++ b/source/libs/planner/src/planScaleOut.c
@@ -129,7 +129,7 @@ static int32_t pushHierarchicalPlan(SNodeList* pParentsGroup, SNodeList* pCurren
   return code;
 }
 
-static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t* pLevel, SNodeList* pParentsGroup) {
+static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pParentsGroup) {
   SNodeList* pCurrentGroup = nodesMakeList();
   if (NULL == pCurrentGroup) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -138,13 +138,13 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32
   int32_t code = TSDB_CODE_SUCCESS;
   switch (pSubplan->subplanType) {
     case SUBPLAN_TYPE_MERGE:
-      code = scaleOutForMerge(pCxt, pSubplan, *pLevel, pCurrentGroup);
+      code = scaleOutForMerge(pCxt, pSubplan, level, pCurrentGroup);
       break;
     case SUBPLAN_TYPE_SCAN:
-      code = scaleOutForScan(pCxt, pSubplan, *pLevel, pCurrentGroup);
+      code = scaleOutForScan(pCxt, pSubplan, level, pCurrentGroup);
       break;
     case SUBPLAN_TYPE_MODIFY:
-      code = scaleOutForModify(pCxt, pSubplan, *pLevel, pCurrentGroup);
+      code = scaleOutForModify(pCxt, pSubplan, level, pCurrentGroup);
       break;
     default:
       break;
@@ -152,13 +152,12 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32
 
   if (TSDB_CODE_SUCCESS == code) {
     code = pushHierarchicalPlan(pParentsGroup, pCurrentGroup);
-    ++(*pLevel);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
     SNode* pChild;
     FOREACH(pChild, pSubplan->pChildren) {
-      code = doScaleOut(pCxt, (SLogicSubplan*)pChild, pLevel, pCurrentGroup);
+      code = doScaleOut(pCxt, (SLogicSubplan*)pChild, level + 1, pCurrentGroup);
       if (TSDB_CODE_SUCCESS != code) {
         break;
       }
@@ -194,7 +193,7 @@ int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQue
   }
 
   SScaleOutContext cxt = { .pPlanCxt = pCxt, .subplanId = 1 };
-  int32_t code = doScaleOut(&cxt, pLogicSubplan, &(pPlan->totalLevel), pPlan->pTopSubplans);
+  int32_t code = doScaleOut(&cxt, pLogicSubplan, 0, pPlan->pTopSubplans);
   if (TSDB_CODE_SUCCESS == code) {
     *pLogicPlan = pPlan;
   } else {
diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c
index e54cf33934..b419414ca6 100644
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
@@ -45,7 +45,17 @@ typedef struct SCtjInfo {
   SLogicSubplan* pSubplan;
 } SCtjInfo;
 
-typedef bool (*FSplFindSplitNode)(SLogicSubplan* pSubplan, SStsInfo* pInfo);
+typedef struct SUaInfo {
+  SProjectLogicNode* pProject;
+  SLogicSubplan* pSubplan;
+} SUaInfo;
+
+typedef struct SUnInfo {
+  SAggLogicNode* pAgg;
+  SLogicSubplan* pSubplan;
+} SUnInfo;
+
+typedef bool (*FSplFindSplitNode)(SLogicSubplan* pSubplan, void* pInfo);
 
 static SLogicSubplan* splCreateScanSubplan(SSplitContext* pCxt, SScanLogicNode* pScan, int32_t flag) {
   SLogicSubplan* pSubplan = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
@@ -132,16 +142,10 @@ static bool stsFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
 
 static int32_t stsSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
   SStsInfo info = {0};
-  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_STS, stsFindSplitNode, &info)) {
+  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_STS, (FSplFindSplitNode)stsFindSplitNode, &info)) {
     return TSDB_CODE_SUCCESS;
   }
-  if (NULL == info.pSubplan->pChildren) {
-    info.pSubplan->pChildren = nodesMakeList();
-    if (NULL == info.pSubplan->pChildren) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-  }
-  int32_t code = nodesListStrictAppend(info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_STS));
+  int32_t code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_STS));
   if (TSDB_CODE_SUCCESS == code) {
     code = splCreateExchangeNode(pCxt, info.pSubplan, info.pScan, SUBPLAN_TYPE_MERGE);
   }
@@ -173,7 +177,7 @@ static SLogicNode* ctjMatchByNode(SLogicNode* pNode) {
   return NULL;
 }
 
-static bool ctjFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
+static bool ctjFindSplitNode(SLogicSubplan* pSubplan, SCtjInfo* pInfo) {
   SLogicNode* pSplitNode = ctjMatchByNode(pSubplan->pNode);
   if (NULL != pSplitNode) {
     pInfo->pScan = (SScanLogicNode*)pSplitNode;
@@ -184,16 +188,10 @@ static bool ctjFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
 
 static int32_t ctjSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
   SCtjInfo info = {0};
-  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_CTJ, ctjFindSplitNode, &info)) {
+  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_CTJ, (FSplFindSplitNode)ctjFindSplitNode, &info)) {
     return TSDB_CODE_SUCCESS;
   }
-  if (NULL == info.pSubplan->pChildren) {
-    info.pSubplan->pChildren = nodesMakeList();
-    if (NULL == info.pSubplan->pChildren) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-  }
-  int32_t code = nodesListStrictAppend(info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_CTJ));
+  int32_t code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_CTJ));
   if (TSDB_CODE_SUCCESS == code) {
     code = splCreateExchangeNode(pCxt, info.pSubplan, info.pScan, info.pSubplan->subplanType);
   }
@@ -202,9 +200,171 @@ static int32_t ctjSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
   return code;
 }
 
+static SLogicNode* uaMatchByNode(SLogicNode* pNode) {
+  if (QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pNode) && LIST_LENGTH(pNode->pChildren) > 1) {
+    return pNode;
+  }
+  SNode* pChild;
+  FOREACH(pChild, pNode->pChildren) {
+    SLogicNode* pSplitNode = uaMatchByNode((SLogicNode*)pChild);
+    if (NULL != pSplitNode) {
+      return pSplitNode;
+    }
+  }
+  return NULL;
+}
+
+static bool uaFindSplitNode(SLogicSubplan* pSubplan, SUaInfo* pInfo) {
+  SLogicNode* pSplitNode = uaMatchByNode(pSubplan->pNode);
+  if (NULL != pSplitNode) {
+    pInfo->pProject = (SProjectLogicNode*)pSplitNode;
+    pInfo->pSubplan = pSubplan;
+  }
+  return NULL != pSplitNode;
+}
+
+static SLogicSubplan* uaCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode) {
+  SLogicSubplan* pSubplan = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
+  if (NULL == pSubplan) {
+    return NULL;
+  }
+  pSubplan->id.groupId = pCxt->groupId;
+  pSubplan->subplanType = SUBPLAN_TYPE_SCAN;
+  pSubplan->pNode = pNode;
+  return pSubplan;
+}
+
+static int32_t uaCreateExchangeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SProjectLogicNode* pProject) {
+  SExchangeLogicNode* pExchange = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
+  if (NULL == pExchange) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pExchange->srcGroupId = pCxt->groupId;
+  // pExchange->precision = pScan->pMeta->tableInfo.precision;
+  pExchange->node.pTargets = nodesCloneList(pProject->node.pTargets);
+  if (NULL == pExchange->node.pTargets) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pSubplan->subplanType = SUBPLAN_TYPE_MERGE;
+
+  if (NULL == pProject->node.pParent) {
+    pSubplan->pNode = (SLogicNode*)pExchange;
+    nodesDestroyNode(pProject);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SNode* pNode;
+  FOREACH(pNode, pProject->node.pParent->pChildren) {
+    if (nodesEqualNode(pNode, pProject)) {
+      REPLACE_NODE(pExchange);
+      nodesDestroyNode(pNode);
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+  nodesDestroyNode(pExchange);
+  return TSDB_CODE_FAILED;
+}
+
+static int32_t uaSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
+  SUaInfo info = {0};
+  if (!splMatch(pCxt, pSubplan, 0, (FSplFindSplitNode)uaFindSplitNode, &info)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SNode* pChild = NULL;
+  FOREACH(pChild, info.pProject->node.pChildren) {
+    code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, uaCreateSubplan(pCxt, (SLogicNode*)pChild));
+    if (TSDB_CODE_SUCCESS == code) {
+      REPLACE_NODE(NULL);
+    } else {
+      break;
+    }
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    nodesClearList(info.pProject->node.pChildren);
+    info.pProject->node.pChildren = NULL;
+    code = uaCreateExchangeNode(pCxt, info.pSubplan, info.pProject);
+  }
+  ++(pCxt->groupId);
+  pCxt->split = true;
+  return code;
+}
+
+static SLogicNode* unMatchByNode(SLogicNode* pNode) {
+  if (QUERY_NODE_LOGIC_PLAN_AGG == nodeType(pNode) && LIST_LENGTH(pNode->pChildren) > 1) {
+    return pNode;
+  }
+  SNode* pChild;
+  FOREACH(pChild, pNode->pChildren) {
+    SLogicNode* pSplitNode = uaMatchByNode((SLogicNode*)pChild);
+    if (NULL != pSplitNode) {
+      return pSplitNode;
+    }
+  }
+  return NULL;
+}
+
+static int32_t unCreateExchangeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SAggLogicNode* pAgg) {
+  SExchangeLogicNode* pExchange = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
+  if (NULL == pExchange) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pExchange->srcGroupId = pCxt->groupId;
+  // pExchange->precision = pScan->pMeta->tableInfo.precision;
+  pExchange->node.pTargets = nodesCloneList(pAgg->node.pTargets);
+  if (NULL == pExchange->node.pTargets) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pSubplan->subplanType = SUBPLAN_TYPE_MERGE;
+
+  return nodesListMakeAppend(&pAgg->node.pChildren, pExchange);
+}
+
+static bool unFindSplitNode(SLogicSubplan* pSubplan, SUnInfo* pInfo) {
+  SLogicNode* pSplitNode = unMatchByNode(pSubplan->pNode);
+  if (NULL != pSplitNode) {
+    pInfo->pAgg = (SAggLogicNode*)pSplitNode;
+    pInfo->pSubplan = pSubplan;
+  }
+  return NULL != pSplitNode;
+}
+
+static int32_t unSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
+  SUnInfo info = {0};
+  if (!splMatch(pCxt, pSubplan, 0, (FSplFindSplitNode)unFindSplitNode, &info)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SNode* pChild = NULL;
+  FOREACH(pChild, info.pAgg->node.pChildren) {
+    code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, uaCreateSubplan(pCxt, (SLogicNode*)pChild));
+    if (TSDB_CODE_SUCCESS == code) {
+      REPLACE_NODE(NULL);
+    } else {
+      break;
+    }
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    nodesClearList(info.pAgg->node.pChildren);
+    info.pAgg->node.pChildren = NULL;
+    code = unCreateExchangeNode(pCxt, info.pSubplan, info.pAgg);
+  }
+  ++(pCxt->groupId);
+  pCxt->split = true;
+  return code;
+}
+
 static const SSplitRule splitRuleSet[] = {
   { .pName = "SuperTableScan", .splitFunc = stsSplit },
   { .pName = "ChildTableJoin", .splitFunc = ctjSplit },
+  { .pName = "UnionAll",       .splitFunc = uaSplit  },
+  { .pName = "Union",          .splitFunc = unSplit  }
 };
 
 static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule));
diff --git a/source/libs/planner/test/planSetOpTest.cpp b/source/libs/planner/test/planSetOpTest.cpp
new file mode 100644
index 0000000000..5ace503959
--- /dev/null
+++ b/source/libs/planner/test/planSetOpTest.cpp
@@ -0,0 +1,35 @@
+/*
+ * 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/>.
+ */
+
+#include "planTestUtil.h"
+#include "planner.h"
+
+using namespace std;
+
+class PlanSetOpTest : public PlannerTestBase {
+
+};
+
+TEST_F(PlanSetOpTest, unionAll) {
+  useDb("root", "test");
+
+  run("select c1, c2 from t1 where c1 > 10 union all select c1, c2 from t1 where c1 > 20");
+}
+
+TEST_F(PlanSetOpTest, union) {
+  useDb("root", "test");
+
+  run("select c1, c2 from t1 where c1 > 10 union select c1, c2 from t1 where c1 > 20");
+}
diff --git a/source/libs/planner/test/plannerTestMain.cpp b/source/libs/planner/test/planTestMain.cpp
similarity index 100%
rename from source/libs/planner/test/plannerTestMain.cpp
rename to source/libs/planner/test/planTestMain.cpp
diff --git a/source/libs/planner/test/planTestUtil.cpp b/source/libs/planner/test/planTestUtil.cpp
index 25457d3e41..222ad9780b 100644
--- a/source/libs/planner/test/planTestUtil.cpp
+++ b/source/libs/planner/test/planTestUtil.cpp
@@ -62,7 +62,11 @@ public:
       doScaleOutLogicPlan(&cxt, pLogicSubplan, &pLogicPlan);
 
       SQueryPlan* pPlan = nullptr;
-      doCreatePhysiPlan(&cxt, pLogicPlan, &pPlan, NULL);
+      doCreatePhysiPlan(&cxt, pLogicPlan, &pPlan);
+
+      if (g_isDump) {
+        dump();
+      }
     } catch (...) {
       dump();
       throw;
@@ -87,6 +91,7 @@ private:
     string splitLogicPlan_;
     string scaledLogicPlan_;
     string physiPlan_;
+    vector<string> physiSubplans_;
   };
 
   void reset() {
@@ -115,6 +120,10 @@ private:
     cout << res_.scaledLogicPlan_ << endl;
     cout << "physical plan : " << endl;
     cout << res_.physiPlan_ << endl;
+    cout << "physical subplan : " << endl;
+    for (const auto& subplan : res_.physiSubplans_) {
+      cout << subplan << endl;
+    }
   }
   
   void doParseSql(const string& sql, SQuery** pQuery) {
@@ -153,9 +162,17 @@ private:
     res_.scaledLogicPlan_ = toString((SNode*)(*pLogicPlan));
   }
 
-  void doCreatePhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList) {
+  void doCreatePhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan) {
+    SArray* pExecNodeList = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SQueryNodeAddr));
     DO_WITH_THROW(createPhysiPlan, pCxt, pLogicPlan, pPlan, pExecNodeList);
     res_.physiPlan_ = toString((SNode*)(*pPlan));
+    SNode* pNode;
+    FOREACH(pNode, (*pPlan)->pSubplans) {
+      SNode* pSubplan;
+      FOREACH(pSubplan, ((SNodeListNode*)pNode)->pNodeList) {
+        res_.physiSubplans_.push_back(toString(pSubplan));
+      }
+    }
   }
 
   void setPlanContext(SQuery* pQuery, SPlanContext* pCxt) {
diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c
index b19757bd05..0559792740 100644
--- a/source/libs/scalar/src/sclfunc.c
+++ b/source/libs/scalar/src/sclfunc.c
@@ -716,7 +716,8 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
           int32_t len = sprintf(varDataVal(output), "%.*s", (int32_t)(outputLen - VARSTR_HEADER_SIZE), *(int8_t *)input ? "true" : "false");
           varDataSetLen(output, len);
         } else if (inputType == TSDB_DATA_TYPE_BINARY) {
-          int32_t len = sprintf(varDataVal(output), "%.*s", (int32_t)(outputLen - VARSTR_HEADER_SIZE), varDataVal(input));
+          int32_t len = MIN(varDataLen(input), outputLen - VARSTR_HEADER_SIZE);
+          len = sprintf(varDataVal(output), "%.*s", len, varDataVal(input));
           varDataSetLen(output, len);
         } else if (inputType == TSDB_DATA_TYPE_NCHAR) {
           //not support
diff --git a/source/libs/transport/inc/transComm.h b/source/libs/transport/inc/transComm.h
index 1b8cbb0f04..e18538cf27 100644
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
@@ -158,6 +158,7 @@ typedef struct {
   char secured : 2;
   char spi : 2;
 
+  char     user[TSDB_UNI_LEN];
   uint64_t ahandle;  // ahandle assigned by client
   uint32_t code;     // del later
   uint32_t msgType;
@@ -186,23 +187,23 @@ typedef enum { Normal, Quit, Release, Register } STransMsgType;
 typedef enum { ConnNormal, ConnAcquire, ConnRelease, ConnBroken, ConnInPool } ConnStatus;
 
 #define container_of(ptr, type, member) ((type*)((char*)(ptr)-offsetof(type, member)))
-#define RPC_RESERVE_SIZE (sizeof(STranConnCtx))
+#define RPC_RESERVE_SIZE                (sizeof(STranConnCtx))
 
-#define RPC_MSG_OVERHEAD (sizeof(SRpcHead) + sizeof(SRpcDigest))
-#define rpcHeadFromCont(cont) ((SRpcHead*)((char*)cont - sizeof(SRpcHead)))
-#define rpcContFromHead(msg) (msg + sizeof(SRpcHead))
+#define RPC_MSG_OVERHEAD           (sizeof(SRpcHead) + sizeof(SRpcDigest))
+#define rpcHeadFromCont(cont)      ((SRpcHead*)((char*)cont - sizeof(SRpcHead)))
+#define rpcContFromHead(msg)       (msg + sizeof(SRpcHead))
 #define rpcMsgLenFromCont(contLen) (contLen + sizeof(SRpcHead))
-#define rpcContLenFromMsg(msgLen) (msgLen - sizeof(SRpcHead))
-#define rpcIsReq(type) (type & 1U)
+#define rpcContLenFromMsg(msgLen)  (msgLen - sizeof(SRpcHead))
+#define rpcIsReq(type)             (type & 1U)
 
 #define TRANS_RESERVE_SIZE (sizeof(STranConnCtx))
 
-#define TRANS_MSG_OVERHEAD (sizeof(STransMsgHead))
-#define transHeadFromCont(cont) ((STransMsgHead*)((char*)cont - sizeof(STransMsgHead)))
-#define transContFromHead(msg) (msg + sizeof(STransMsgHead))
+#define TRANS_MSG_OVERHEAD           (sizeof(STransMsgHead))
+#define transHeadFromCont(cont)      ((STransMsgHead*)((char*)cont - sizeof(STransMsgHead)))
+#define transContFromHead(msg)       (msg + sizeof(STransMsgHead))
 #define transMsgLenFromCont(contLen) (contLen + sizeof(STransMsgHead))
-#define transContLenFromMsg(msgLen) (msgLen - sizeof(STransMsgHead));
-#define transIsReq(type) (type & 1U)
+#define transContLenFromMsg(msgLen)  (msgLen - sizeof(STransMsgHead));
+#define transIsReq(type)             (type & 1U)
 
 int       rpcAuthenticateMsg(void* pMsg, int msgLen, void* pAuth, void* pKey);
 void      rpcBuildAuthHead(void* pMsg, int msgLen, void* pAuth, void* pKey);
diff --git a/source/libs/transport/inc/transportInt.h b/source/libs/transport/inc/transportInt.h
index ad50948a02..eaca9b0fc7 100644
--- a/source/libs/transport/inc/transportInt.h
+++ b/source/libs/transport/inc/transportInt.h
@@ -63,13 +63,14 @@ typedef struct {
 
   void (*cfp)(void* parent, SRpcMsg*, SEpSet*);
   int (*afp)(void* parent, char* user, char* spi, char* encrypt, char* secret, char* ckey);
+  int (*retry)(void* parent, SRpcMsg*, SEpSet*);
 
-  int32_t         refCount;
-  void*           parent;
-  void*           idPool;     // handle to ID pool
-  void*           tmrCtrl;    // handle to timer
-  SHashObj*       hash;       // handle returned by hash utility
-  void*           tcphandle;  // returned handle from TCP initialization
+  int32_t       refCount;
+  void*         parent;
+  void*         idPool;     // handle to ID pool
+  void*         tmrCtrl;    // handle to timer
+  SHashObj*     hash;       // handle returned by hash utility
+  void*         tcphandle;  // returned handle from TCP initialization
   TdThreadMutex mutex;
 } SRpcInfo;
 
diff --git a/source/libs/transport/src/trans.c b/source/libs/transport/src/trans.c
index ebb90338cd..fa517d6d61 100644
--- a/source/libs/transport/src/trans.c
+++ b/source/libs/transport/src/trans.c
@@ -39,6 +39,7 @@ void* rpcOpen(const SRpcInit* pInit) {
   // register callback handle
   pRpc->cfp = pInit->cfp;
   pRpc->afp = pInit->afp;
+  pRpc->retry = pInit->rfp;
 
   if (pInit->connType == TAOS_CONN_SERVER) {
     pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
@@ -100,11 +101,10 @@ void rpcSendRedirectRsp(void* thandle, const SEpSet* pEpSet) {
   SRpcMsg rpcMsg;
   memset(&rpcMsg, 0, sizeof(rpcMsg));
 
-  rpcMsg.contLen = sizeof(SEpSet);
-  rpcMsg.pCont = rpcMallocCont(rpcMsg.contLen);
-  if (rpcMsg.pCont == NULL) return;
-
-  memcpy(rpcMsg.pCont, pEpSet, sizeof(SEpSet));
+  SMEpSet msg = {.epSet = *pEpSet};
+  int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
+  rpcMsg.pCont = rpcMallocCont(len);
+  tSerializeSMEpSet(rpcMsg.pCont, len, &msg);
 
   rpcMsg.code = TSDB_CODE_RPC_REDIRECT;
   rpcMsg.handle = thandle;
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 8eb1a3ee7d..b43b8a1e0c 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -31,12 +31,8 @@ typedef struct SCliConn {
   int          hThrdIdx;
   STransCtx    ctx;
 
-  bool       broken;   // link broken or not
-  ConnStatus status;   //
-  int        release;  // 1: release
-  // spi configure
-  char spi;
-  char secured;
+  bool       broken;  // link broken or not
+  ConnStatus status;  //
 
   char*    ip;
   uint32_t port;
@@ -44,7 +40,6 @@ typedef struct SCliConn {
   // debug and log info
   struct sockaddr_in addr;
   struct sockaddr_in locaddr;
-
 } SCliConn;
 
 typedef struct SCliMsg {
@@ -102,6 +97,8 @@ static void cliSendCb(uv_write_t* req, int status);
 static void cliConnCb(uv_connect_t* req, int status);
 static void cliAsyncCb(uv_async_t* handle);
 
+static void cliAppCb(SCliConn* pConn, STransMsg* pMsg);
+
 static SCliConn* cliCreateConn(SCliThrdObj* thrd);
 static void      cliDestroyConn(SCliConn* pConn, bool clear /*clear tcp handle or not*/);
 static void      cliDestroy(uv_handle_t* handle);
@@ -303,8 +300,6 @@ void cliHandleResp(SCliConn* conn) {
          TMSG_INFO(pHead->msgType), taosInetNtoa(conn->addr.sin_addr), ntohs(conn->addr.sin_port),
          taosInetNtoa(conn->locaddr.sin_addr), ntohs(conn->locaddr.sin_port), transMsg.contLen);
 
-  conn->secured = pHead->secured;
-
   if (pCtx == NULL && CONN_NO_PERSIST_BY_APP(conn)) {
     tTrace("except, server continue send while cli ignore it");
     // transUnrefCliHandle(conn);
@@ -318,7 +313,8 @@ void cliHandleResp(SCliConn* conn) {
 
   if (pCtx == NULL || pCtx->pSem == NULL) {
     tTrace("%s cli conn %p handle resp", pTransInst->label, conn);
-    (pTransInst->cfp)(pTransInst->parent, &transMsg, NULL);
+    cliAppCb(conn, &transMsg);
+    //(pTransInst->cfp)(pTransInst->parent, &transMsg, NULL);
   } else {
     tTrace("%s cli conn(sync) %p handle resp", pTransInst->label, conn);
     memcpy((char*)pCtx->pRsp, (char*)&transMsg, sizeof(transMsg));
@@ -384,7 +380,8 @@ void cliHandleExcept(SCliConn* pConn) {
         once = true;
         continue;
       }
-      (pTransInst->cfp)(pTransInst->parent, &transMsg, NULL);
+      cliAppCb(pConn, &transMsg);
+      //(pTransInst->cfp)(pTransInst->parent, &transMsg, NULL);
     } else {
       tTrace("%s cli conn(sync) %p handle except", pTransInst->label, pConn);
       memcpy((char*)(pCtx->pRsp), (char*)(&transMsg), sizeof(transMsg));
@@ -614,35 +611,16 @@ void cliSend(SCliConn* pConn) {
     pMsg->pCont = (void*)rpcMallocCont(0);
     pMsg->contLen = 0;
   }
-  STransMsgHead* pHead = transHeadFromCont(pMsg->pCont);
-  pHead->ahandle = pCtx != NULL ? (uint64_t)pCtx->ahandle : 0;
-
   int msgLen = transMsgLenFromCont(pMsg->contLen);
 
-  if (!pConn->secured) {
-    char* buf = taosMemoryCalloc(1, msgLen + sizeof(STransUserMsg));
-    memcpy(buf, (char*)pHead, msgLen);
-
-    STransUserMsg* uMsg = (STransUserMsg*)(buf + msgLen);
-    memcpy(uMsg->user, pTransInst->user, tListLen(uMsg->user));
-    memcpy(uMsg->secret, pTransInst->secret, tListLen(uMsg->secret));
-
-    // to avoid mem leak
-    destroyUserdata(pMsg);
-
-    pMsg->pCont = (char*)buf + sizeof(STransMsgHead);
-    pMsg->contLen = msgLen + sizeof(STransUserMsg) - sizeof(STransMsgHead);
-
-    pHead = (STransMsgHead*)buf;
-    pHead->secured = 1;
-    msgLen += sizeof(STransUserMsg);
-  }
-
+  STransMsgHead* pHead = transHeadFromCont(pMsg->pCont);
+  pHead->ahandle = pCtx != NULL ? (uint64_t)pCtx->ahandle : 0;
   pHead->noResp = REQUEST_NO_RESP(pMsg) ? 1 : 0;
   pHead->persist = REQUEST_PERSIS_HANDLE(pMsg) ? 1 : 0;
   pHead->msgType = pMsg->msgType;
   pHead->msgLen = (int32_t)htonl((uint32_t)msgLen);
   pHead->release = REQUEST_RELEASE_HANDLE(pCliMsg) ? 1 : 0;
+  memcpy(pHead->user, pTransInst->user, strlen(pTransInst->user));
 
   uv_buf_t wb = uv_buf_init((char*)pHead, msgLen);
   tDebug("%s cli conn %p %s is send to %s:%d, local info %s:%d", CONN_GET_INST_LABEL(pConn), pConn,
@@ -903,6 +881,18 @@ int cliRBChoseIdx(STrans* pTransInst) {
   }
   return index % pTransInst->numOfThreads;
 }
+void cliAppCb(SCliConn* pConn, STransMsg* transMsg) {
+  SCliThrdObj* pThrd = pConn->hostThrd;
+  STrans*      pTransInst = pThrd->pTransInst;
+
+  if (transMsg->code == TSDB_CODE_RPC_REDIRECT && pTransInst->retry != NULL) {
+    SMEpSet emsg = {0};
+    tDeserializeSMEpSet(transMsg->pCont, transMsg->contLen, &emsg);
+    pTransInst->retry(pTransInst, transMsg, &(emsg.epSet));
+  } else {
+    pTransInst->cfp(pTransInst->parent, transMsg, NULL);
+  }
+}
 
 void transCloseClient(void* arg) {
   SCliObj* cli = arg;
diff --git a/source/libs/transport/src/transSrv.c b/source/libs/transport/src/transSrv.c
index 158d599bdf..59a30051ef 100644
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
@@ -30,7 +30,6 @@ typedef struct SSrvConn {
   uv_timer_t pTimer;
 
   queue       queue;
-  int         ref;
   int         persist;  // persist connection or not
   SConnBuffer readBuf;  // read buf,
   int         inType;
@@ -46,7 +45,6 @@ typedef struct SSrvConn {
   struct sockaddr_in addr;
   struct sockaddr_in locaddr;
 
-  char secured;
   int  spi;
   char info[64];
   char user[TSDB_UNI_LEN];  // user ID for the link
@@ -104,6 +102,13 @@ static void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf)
 static void uvWorkerAsyncCb(uv_async_t* handle);
 static void uvAcceptAsyncCb(uv_async_t* handle);
 static void uvShutDownCb(uv_shutdown_t* req, int status);
+
+/*
+ * time-consuming task throwed into BG work thread
+ */
+static void uvWorkDoTask(uv_work_t* req);
+static void uvWorkAfterTask(uv_work_t* req, int status);
+
 static void uvWalkCb(uv_handle_t* handle, void* arg);
 static void uvFreeCb(uv_handle_t* handle);
 
@@ -181,16 +186,16 @@ static void uvHandleReq(SSrvConn* pConn) {
   uint32_t     msgLen = pBuf->len;
 
   STransMsgHead* pHead = (STransMsgHead*)msg;
-  if (pHead->secured == 1) {
-    STransUserMsg* uMsg = (STransUserMsg*)((char*)msg + msgLen - sizeof(STransUserMsg));
-    memcpy(pConn->user, uMsg->user, tListLen(uMsg->user));
-    memcpy(pConn->secret, uMsg->secret, tListLen(uMsg->secret));
-  }
   pHead->code = htonl(pHead->code);
   pHead->msgLen = htonl(pHead->msgLen);
-  if (pHead->secured == 1) {
-    pHead->msgLen -= sizeof(STransUserMsg);
-  }
+  memcpy(pConn->user, pHead->user, strlen(pHead->user));
+
+  // TODO(dengyihao): time-consuming task throwed into BG Thread
+  //  uv_work_t* wreq = taosMemoryMalloc(sizeof(uv_work_t));
+  //  wreq->data = pConn;
+  //  uv_read_stop((uv_stream_t*)pConn->pTcp);
+  //  transRefSrvHandle(pConn);
+  //  uv_queue_work(((SWorkThrdObj*)pConn->hostThrd)->loop, wreq, uvWorkDoTask, uvWorkAfterTask);
 
   CONN_SHOULD_RELEASE(pConn, pHead);
 
@@ -344,12 +349,6 @@ static void uvPrepareSendData(SSrvMsg* smsg, uv_buf_t* wb) {
   STransMsgHead* pHead = transHeadFromCont(pMsg->pCont);
   pHead->ahandle = (uint64_t)pMsg->ahandle;
 
-  // pHead->secured = pMsg->code == 0 ? 1 : 0;  //
-  if (!pConn->secured) {
-    pConn->secured = pMsg->code == 0 ? 1 : 0;
-  }
-  pHead->secured = pConn->secured;
-
   if (pConn->status == ConnNormal) {
     pHead->msgType = pConn->inType + 1;
   } else {
@@ -464,6 +463,24 @@ static void uvShutDownCb(uv_shutdown_t* req, int status) {
   taosMemoryFree(req);
 }
 
+static void uvWorkDoTask(uv_work_t* req) {
+  // doing time-consumeing task
+  // only auth conn currently, add more func later
+  tTrace("server conn %p start to be processed in BG Thread", req->data);
+  return;
+}
+
+static void uvWorkAfterTask(uv_work_t* req, int status) {
+  if (status != 0) {
+    tTrace("server conn %p failed to processed ", req->data);
+  }
+  // Done time-consumeing task
+  // add more func later
+  // this func called in main loop
+  tTrace("server conn %p already processed ", req->data);
+  taosMemoryFree(req);
+}
+
 void uvOnAcceptCb(uv_stream_t* stream, int status) {
   if (status == -1) {
     return;
@@ -674,8 +691,6 @@ static void uvDestroyConn(uv_handle_t* handle) {
   if (thrd->quit && QUEUE_IS_EMPTY(&thrd->conn)) {
     tTrace("work thread quit");
     uv_walk(thrd->loop, uvWalkCb, NULL);
-    // uv_loop_close(thrd->loop);
-    // uv_stop(thrd->loop);
   }
 }
 
@@ -738,8 +753,6 @@ void uvHandleQuit(SSrvMsg* msg, SWorkThrdObj* thrd) {
   thrd->quit = true;
   if (QUEUE_IS_EMPTY(&thrd->conn)) {
     uv_walk(thrd->loop, uvWalkCb, NULL);
-    // uv_loop_close(thrd->loop);
-    // uv_stop(thrd->loop);
   } else {
     destroyAllConn(thrd);
   }
@@ -833,10 +846,8 @@ void transRefSrvHandle(void* handle) {
   if (handle == NULL) {
     return;
   }
-  SSrvConn* conn = handle;
-
   int ref = T_REF_INC((SSrvConn*)handle);
-  UNUSED(ref);
+  tDebug("server conn %p ref count: %d", handle, ref);
 }
 
 void transUnrefSrvHandle(void* handle) {
diff --git a/source/os/src/osEnv.c b/source/os/src/osEnv.c
index 22884298ef..e24ac41f20 100644
--- a/source/os/src/osEnv.c
+++ b/source/os/src/osEnv.c
@@ -37,6 +37,7 @@ int64_t         tsOpenMax = 0;
 int64_t         tsStreamMax = 0;
 float           tsNumOfCores = 0;
 int64_t         tsTotalMemoryKB = 0;
+char*           tsProcPath = NULL;
 
 void osDefaultInit() {
   taosSeedRand(taosSafeRand());
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index 3d3d13fcb6..4f2f99dec7 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -380,7 +380,7 @@ int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
 #if FILE_WITH_LOCK
   taosThreadRwlockWrlock(&(pFile->rwlock));
 #endif
-  /*assert(pFile->fd >= 0); // Please check if you have closed the file.*/
+  assert(pFile->fd >= 0);  // Please check if you have closed the file.
 
   int64_t nleft = count;
   int64_t nwritten = 0;
diff --git a/source/os/src/osProc.c b/source/os/src/osProc.c
index b6de638ac2..d569582256 100644
--- a/source/os/src/osProc.c
+++ b/source/os/src/osProc.c
@@ -17,7 +17,7 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 
-static char *tsProcPath = NULL;
+char *tsProcPath = NULL;
 
 int32_t taosNewProc(char **args) {
   int32_t pid = fork();
diff --git a/source/util/src/talgo.c b/source/util/src/talgo.c
index 48a0f327c4..8675670cfe 100644
--- a/source/util/src/talgo.c
+++ b/source/util/src/talgo.c
@@ -229,22 +229,21 @@ void *taosbsearch(const void *key, const void *base, int64_t nmemb, int64_t size
 }
 
 void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar,
-                    __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot) {
+                    __ext_compar_fn_t compar, char* buf, bool maxroot) {
   int32_t parent;
   int32_t child;
-  char   *buf;
+
+  char* tmp = NULL;
+  if (buf == NULL) {
+    tmp = taosMemoryMalloc(size);
+  } else {
+    tmp = buf;
+  }
 
   if (base && size > 0 && compar) {
     parent = start;
     child = 2 * parent + 1;
 
-    if (swap == NULL) {
-      buf = taosMemoryCalloc(1, size);
-      if (buf == NULL) {
-        return;
-      }
-    }
-
     if (maxroot) {
       while (child <= end) {
         if (child + 1 <= end &&
@@ -256,11 +255,7 @@ void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const
           break;
         }
 
-        if (swap == NULL) {
-          doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, buf);
-        } else {
-          (*swap)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parswap);
-        }
+        doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, tmp);
 
         parent = child;
         child = 2 * parent + 1;
@@ -276,33 +271,35 @@ void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const
           break;
         }
 
-        if (swap == NULL) {
-          doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, buf);
-        } else {
-          (*swap)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parswap);
-        }
+        doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, tmp);
 
         parent = child;
         child = 2 * parent + 1;
       }
     }
+  }
 
-    if (swap == NULL) {
-      taosMemoryFreeClear(buf);
-    }
+  if (buf == NULL) {
+    taosMemoryFree(tmp);
   }
 }
 
 void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar,
-                  const void *parswap, __ext_swap_fn_t swap, bool maxroot) {
+                  bool maxroot) {
   int32_t i;
 
+  char* buf = taosMemoryCalloc(1, size);
+  if (buf == NULL) {
+    return;
+  }
+
   if (base && size > 0) {
     for (i = len / 2 - 1; i >= 0; i--) {
-      taosheapadjust(base, size, i, len - 1, parcompar, compar, parswap, swap, maxroot);
+      taosheapadjust(base, size, i, len - 1, parcompar, compar, buf, maxroot);
     }
   }
 
+  taosMemoryFree(buf);
   /*
     char *buf = taosMemoryCalloc(1, size);
 
diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c
index 6da4913114..c57883cb73 100644
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
@@ -222,7 +222,7 @@ static void *taosThreadToOpenNewFile(void *param) {
   tsLogObj.logHandle->pFile = pFile;
   tsLogObj.lines = 0;
   tsLogObj.openInProgress = 0;
-  taosSsleep(3);
+  taosSsleep(10);
   taosCloseLogByFd(pOldFile);
 
   uInfo("   new log file:%d is opened", tsLogObj.flag);
diff --git a/tests/script/runAllSimCases.sh b/tests/script/runAllSimCases.sh
index 279bc8363e..97bebd9eb8 100755
--- a/tests/script/runAllSimCases.sh
+++ b/tests/script/runAllSimCases.sh
@@ -1,4 +1,4 @@
-!/bin/bash
+#!/bin/bash
 
 ##################################################
 # 
diff --git a/tests/script/test.sh b/tests/script/test.sh
index 14dc43beaf..e4191da0a9 100755
--- a/tests/script/test.sh
+++ b/tests/script/test.sh
@@ -131,8 +131,8 @@ if [ -n "$FILE_NAME" ]; then
       FLAG="-v"    
     fi 
   
-    echo valgrind --tool=memcheck --leak-check=full --show-reachable=no  --track-origins=yes --show-leak-kinds=all  -v  --workaround-gcc296-bugs=yes  --log-file=${LOG_DIR}/valgrind-tsim.log $PROGRAM -c $CFG_DIR -f $FILE_NAME $FLAG
-    valgrind --tool=memcheck --leak-check=full --show-reachable=no  --track-origins=yes --show-leak-kinds=all  -v  --workaround-gcc296-bugs=yes  --log-file=${LOG_DIR}/valgrind-tsim.log $PROGRAM -c $CFG_DIR -f $FILE_NAME $FLAG
+    echo valgrind --tool=memcheck --leak-check=full --show-reachable=no  --track-origins=yes --child-silent-after-fork=yes --show-leak-kinds=all  -v  --workaround-gcc296-bugs=yes  --log-file=${LOG_DIR}/valgrind-tsim.log $PROGRAM -c $CFG_DIR -f $FILE_NAME $FLAG
+    valgrind --tool=memcheck --leak-check=full --show-reachable=no  --track-origins=yes --child-silent-after-fork=yes --show-leak-kinds=all  -v  --workaround-gcc296-bugs=yes  --log-file=${LOG_DIR}/valgrind-tsim.log $PROGRAM -c $CFG_DIR -f $FILE_NAME $FLAG
   else
     if [[ $MULTIPROCESS -eq 1 ]];then
       echo "ExcuteCmd(multiprocess):" $PROGRAM -m -c $CFG_DIR -f $FILE_NAME  
diff --git a/tests/script/tsim/query/session.sim b/tests/script/tsim/query/session.sim
index d5e77c7b28..a69b6249fc 100644
--- a/tests/script/tsim/query/session.sim
+++ b/tests/script/tsim/query/session.sim
@@ -279,7 +279,8 @@ endi
 
 print ================> syntax error check not active ================> reactive
 sql_error select * from dev_001 session(ts,1w)
-sql_error select count(*) from st session(ts,1w)
+print disable this temporarily, session can not be directly applied to super table.
+#sql_error select count(*) from st session(ts,1w)
 sql_error select count(*) from dev_001 group by tagtype session(ts,1w)
 sql_error sql select count(*) from dev_001 session(ts,1n)
 sql_error sql select count(*) from dev_001 session(ts,1y)
diff --git a/tests/script/tsim/tmq/basic1.sim b/tests/script/tsim/tmq/basic1.sim
index 60064b174e..df6a553d1a 100644
--- a/tests/script/tsim/tmq/basic1.sim
+++ b/tests/script/tsim/tmq/basic1.sim
@@ -8,196 +8,245 @@
 #
 # notes2: not support aggregate functions(such as sum/count/min/max) and time-windows(interval).
 #
-system sh/stop_dnodes.sh
 
-system sh/deploy.sh -n dnode1 -i 1
-system sh/exec.sh -n dnode1 -s start
+run tsim/tmq/prepareBasicEnv.sim
 
-$loop_cnt = 0
-check_dnode_ready:
-	$loop_cnt = $loop_cnt + 1
-	sleep 200
-	if $loop_cnt == 10 then
-	  print ====> dnode not ready!
-		return -1
-	endi
-sql show dnodes
-print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
-if $data00 != 1 then
-  return -1
-endi
-if $data04 != ready then
-  goto check_dnode_ready
-endi
+#---- global parameters start ----#
+$dbName    = db
+$vgroups    = 1
+$stbPrefix  = stb
+$ctbPrefix  = ctb
+$ntbPrefix  = ntb
+$stbNum     = 1
+$ctbNum     = 10
+$ntbNum     = 10
+$rowsPerCtb = 100
+$tstart     = 1640966400000  # 2022-01-01 00:00:00.000
+#---- global parameters end ----#
+
+$pullDelay    = 3
+$ifcheckdata  = 1
+$showMsg      = 1
+$showRow      = 0
 
 sql connect
+sql use $dbName
 
-$dbNamme = d0
-print =============== create database , vgroup 4
-sql create database $dbNamme vgroups 4
-sql use $dbNamme
-
-print =============== create super table
-sql create table if not exists stb (ts timestamp, c1 int, c2 float, c3 binary(10)) tags (t1 int)
-
-sql show stables
-if $rows != 1 then 
-  return -1
-endi
-
-print =============== create child table
-sql create table ct0 using stb tags(1000)
-sql create table ct1 using stb tags(2000)
-#sql create table ct3 using stb tags(3000)
-
-print =============== create normal table
-sql create table ntb (ts timestamp, c1 int, c2 float, c3 binary(10))
-
-print =============== create multi topics. notes: now only support:
-print =============== 1. columns from stb; 2. * from ctb; 3. columns from ctb
-print =============== will support: * from stb; function from stb/ctb
-
-sql create topic topic_stb_column as select ts, c1, c3 from stb
-#sql create topic topic_stb_all as select * from stb
+print == create topics from super table
+sql create topic topic_stb_column as select ts, c3 from stb
+sql create topic topic_stb_all as select ts, c1, c2, c3 from stb
 sql create topic topic_stb_function as select ts, abs(c1), sin(c2) from stb
 
-sql create topic topic_ctb_column as select ts, c1, c3 from ct0
-sql create topic topic_ctb_all as select * from ct0
-sql create topic topic_ctb_function as select ts, abs(c1), sin(c2) from ct0
+print == create topics from child table
+sql create topic topic_ctb_column as select ts, c3 from ctb0
+sql create topic topic_ctb_all as select * from ctb0
+sql create topic topic_ctb_function as select ts, abs(c1), sin(c2) from ctb0
 
-sql create topic topic_ntb_column as select ts, c1, c3 from ntb
-sql create topic topic_ntb_all as select * from ntb
-sql create topic topic_ntb_function as select ts, abs(c1), sin(c2) from ntb
+print == create topics from normal table
+sql create topic topic_ntb_column as select ts, c3 from ntb0
+sql create topic topic_ntb_all as select * from ntb0
+sql create topic topic_ntb_function as select ts, abs(c1), sin(c2) from ntb0
 
-sql show tables
-if $rows != 3 then 
-  return -1
-endi
-
-print =============== insert data
-
-$tbPrefix = ct
-$tbNum = 2
-$rowNum = 10
-$tstart = 1640966400000  # 2022-01-01 00:00:00.000
-
-$i = 0
-while $i < $tbNum
-  $tb = $tbPrefix . $i
-
-  $x = 0
-  while $x < $rowNum
-    $c = $x / 10
-    $c = $c * 10
-    $c = $x - $c
-
-    $binary = ' . binary
-    $binary = $binary . $c
-    $binary = $binary . '
-
-    sql insert into $tb values ($tstart , $c , $x , $binary )
-    sql insert into ntb values ($tstart , $c , $x , $binary )
-    $tstart = $tstart + 1
-    $x = $x + 1
-  endw
-
-  $i = $i + 1
-  $tstart = 1640966400000
-endw
-
-#root@trd02 /home $ tmq_sim --help                                                                          
-# -c      Configuration directory, default is 
-# -d      The name of the database for cosumer, no default 
-# -t      The topic string for cosumer, no default 
-# -k      The key-value string for cosumer, no default 
-# -g      showMsgFlag, default is 0
-#        
-
-$totalMsgCnt = $rowNum * $tbNum
-print inserted totalMsgCnt: $totalMsgCnt
-
-# supported key:
-# group.id:<xxx>
-# enable.auto.commit:<true | false>
-# auto.offset.reset:<earliest | latest | none>
-# td.connect.ip:<fqdn | ipaddress>
-# td.connect.user:root
-# td.connect.pass:taosdata
-# td.connect.port:6030
-# td.connect.db:db
-
-system_content echo -n \$BUILD_DIR
-$tmq_sim = $system_content . /build/bin/tmq_sim
-system_content echo -n \$SIM_DIR
-$tsim_cfg = $system_content . /tsim/cfg
-
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_column" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_column" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 20, 0}@ then
-  return -1
-endi
-
-#print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_all" -k "group.id:tg2"
-#system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_all" -k "group.id:tg2"
-#print cmd result----> $system_content
-#if $system_content != @{consume success: 20, 0}@ then
+#sql show topics
+#if $rows != 9 then 
 #  return -1
 #endi
 
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_function" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_stb_function" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 20, 0}@ then
-  print expect @{consume success: 20, 0}@, actual: $system_content
-  return -1
+$keyList = ' . group.id:cgrp1
+$keyList = $keyList . '
+
+print ================ test consume from stb
+$loop_cnt = 0
+loop_consume_diff_topic_from_stb:
+if $loop_cnt == 0 then
+  print == scenario 1: topic_stb_column
+  $topicList = ' . topic_stb_column
+  $topicList = $topicList . '
+elif $loop_cnt == 1 then
+  print == scenario 2: topic_stb_all
+  $topicList = ' . topic_stb_all
+  $topicList = $topicList . '
+elif $loop_cnt == 2 then
+  print == scenario 3: topic_stb_function
+  $topicList = ' . topic_stb_function
+  $topicList = $topicList . '
+else
+  goto loop_consume_diff_topic_from_stb_end
 endi
 
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_column" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_column" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 10, 0}@ then
+$consumerId    = 0
+$totalMsgOfStb = $ctbNum * $rowsPerCtb
+#$expectmsgcnt  = $totalMsgOfStb + 1
+$expectmsgcnt  = 110
+sql insert into consumeinfo values (now , $consumerId , $topicList , $keyList , $expectmsgcnt , $ifcheckdata )
+
+print == start consumer to pull msgs from stb
+print == tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -w $dbName -s start
+system tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -w $dbName -s start
+
+print == check consume result
+wait_consumer_end_from_stb:
+sql select * from consumeresult
+print ==> rows: $rows 
+print ==> rows[0]: $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
+if $rows != 1 then
+  sleep 1000
+  goto wait_consumer_end_from_stb
+endi
+if $data[0][1] != $consumerId then
   return -1
 endi
-
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_all" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_all" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 10, 0}@ then
+if $data[0][2] != $expectmsgcnt then
   return -1
 endi
-
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_function" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ctb_function" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 10, 0}@ then
+if $data[0][3] != $expectmsgcnt then
   return -1
 endi
+$loop_cnt = $loop_cnt + 1
+goto loop_consume_diff_topic_from_stb
+loop_consume_diff_topic_from_stb_end:
 
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_column" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_column" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 20, 0}@ then
+#######################################################################################
+# clear consume info and consume result 
+#run tsim/tmq/clearConsume.sim
+# because drop table function no stable, so by create new db for consume info and result. Modify it later
+$cdbName = cdb1
+sql create database $cdbName vgroups 1
+sleep 500
+sql use $cdbName
+
+print == create consume info table and consume result table
+sql create table consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int)
+sql create table consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)
+
+sql show tables
+if $rows != 2 then 
   return -1
 endi
+#######################################################################################
 
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_all" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_all" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 20, 0}@ then
-  return -1
+
+print ================ test consume from ctb
+$loop_cnt = 0
+loop_consume_diff_topic_from_ctb:
+if $loop_cnt == 0 then
+  print == scenario 1: topic_ctb_column
+  $topicList = ' . topic_ctb_column
+  $topicList = $topicList . '
+elif $loop_cnt == 1 then
+  print == scenario 2: topic_ctb_all
+  $topicList = ' . topic_ctb_all
+  $topicList = $topicList . '
+elif $loop_cnt == 2 then
+  print == scenario 3: topic_ctb_function
+  $topicList = ' . topic_ctb_function
+  $topicList = $topicList . '
+else
+  goto loop_consume_diff_topic_from_ctb_end
 endi
 
-print cmd===> system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_function" -k "group.id:tg2"
-system_content $tmq_sim -c $tsim_cfg -d $dbNamme -t "topic_ntb_function" -k "group.id:tg2"
-print cmd result----> $system_content
-if $system_content != @{consume success: 20, 0}@ then
+$consumerId    = 0
+$totalMsgOfCtb = $rowsPerCtb
+$expectmsgcnt  = $totalMsgOfCtb + 1
+sql insert into consumeinfo values (now , $consumerId , $topicList , $keyList , $expectmsgcnt , $ifcheckdata )
+
+print == start consumer to pull msgs from stb
+print == tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -s start
+system tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -w $cdbName -s start
+
+print == check consume result
+wait_consumer_end_from_ctb:
+sql select * from consumeresult
+print ==> rows: $rows 
+print ==> rows[0]: $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
+if $rows != 1 then
+  sleep 1000
+  goto wait_consumer_end_from_ctb
+endi
+if $data[0][1] != $consumerId then
   return -1
 endi
+if $data[0][2] != $totalMsgOfCtb then
+  return -1
+endi
+if $data[0][3] != $totalMsgOfCtb then
+  return -1
+endi
+$loop_cnt = $loop_cnt + 1
+goto loop_consume_diff_topic_from_ctb
+loop_consume_diff_topic_from_ctb_end:
 
-print =============== create database , vgroup 4
-$dbNamme = d1
-sql create database $dbNamme vgroups 4
+#######################################################################################
+# clear consume info and consume result 
+#run tsim/tmq/clearConsume.sim
+# because drop table function no stable, so by create new db for consume info and result. Modify it later
+$cdbName = cdb2
+sql create database $cdbName vgroups 1
+sleep 500
+sql use $cdbName
 
+print == create consume info table and consume result table
+sql create table consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int)
+sql create table consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)
+
+sql show tables
+if $rows != 2 then 
+  return -1
+endi
+#######################################################################################
+
+
+print ================ test consume from ntb
+$loop_cnt = 0
+loop_consume_diff_topic_from_ntb:
+if $loop_cnt == 0 then
+  print == scenario 1: topic_ntb_column
+  $topicList = ' . topic_ntb_column
+  $topicList = $topicList . '
+elif $loop_cnt == 1 then
+  print == scenario 2: topic_ntb_all
+  $topicList = ' . topic_ntb_all
+  $topicList = $topicList . '
+elif $loop_cnt == 2 then
+  print == scenario 3: topic_ntb_function
+  $topicList = ' . topic_ntb_function
+  $topicList = $topicList . '
+else
+  goto loop_consume_diff_topic_from_ntb_end
+endi
+
+$consumerId    = 0
+$totalMsgOfNtb = $rowsPerCtb
+$expectmsgcnt  = $totalMsgOfNtb + 1
+sql insert into consumeinfo values (now , $consumerId , $topicList , $keyList , $expectmsgcnt , $ifcheckdata )
+
+print == start consumer to pull msgs from stb
+print == tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -s start
+system tsim/tmq/consume.sh -d $dbName -y $pullDelay -g $showMsg -r $showRow -w $cdbName -s start
+
+print == check consume result from ntb
+wait_consumer_end_from_ntb:
+sql select * from consumeresult
+print ==> rows: $rows 
+print ==> rows[0]: $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
+if $rows != 1 then
+  sleep 1000
+  goto wait_consumer_end_from_ntb
+endi
+if $data[0][1] != $consumerId then
+  return -1
+endi
+if $data[0][2] != $totalMsgOfNtb then
+  return -1
+endi
+if $data[0][3] != $totalMsgOfNtb then
+  return -1
+endi
+$loop_cnt = $loop_cnt + 1
+goto loop_consume_diff_topic_from_ntb
+loop_consume_diff_topic_from_ntb_end:
+
+#------ not need stop consumer, because it exit after pull msg overthan expect msg
+#system tsim/tmq/consume.sh -s stop -x SIGINT
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/tsim/tmq/clearConsume.sim b/tests/script/tsim/tmq/clearConsume.sim
new file mode 100644
index 0000000000..8b55e0f8c3
--- /dev/null
+++ b/tests/script/tsim/tmq/clearConsume.sim
@@ -0,0 +1,28 @@
+sql connect
+
+#---- global parameters start ----#
+$dbName    = db
+$vgroups    = 1
+$stbPrefix  = stb
+$ctbPrefix  = ctb
+$ntbPrefix  = ntb
+$stbNum     = 1
+$ctbNum     = 10
+$ntbNum     = 10
+$rowsPerCtb = 100
+$tstart     = 1640966400000  # 2022-01-01 00:00:00.000
+#---- global parameters end ----#
+
+sql use $dbName
+
+print == create consume info table and consume result table
+sql drop table consumeinfo
+sql drop table consumeresult
+sql create table consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int)
+sql create table consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)
+
+sql show tables
+if $rows != 2 then 
+  return -1
+endi
+
diff --git a/tests/script/tsim/tmq/consume.sh b/tests/script/tsim/tmq/consume.sh
index ac500e6704..28e03d8fb9 100755
--- a/tests/script/tsim/tmq/consume.sh
+++ b/tests/script/tsim/tmq/consume.sh
@@ -11,16 +11,25 @@ set +e
 # set default value for parameters
 EXEC_OPTON=start
 DB_NAME=db 
+CDB_NAME=db
 POLL_DELAY=5
 VALGRIND=0
 SIGNAL=SIGINT
+SHOW_MSG=0
+SHOW_ROW=0
 
-while getopts "d:s:v:y:x:" arg
+while getopts "d:s:v:y:x:g:r:w:" arg
 do
   case $arg in
     d)
       DB_NAME=$OPTARG
       ;;
+    g)
+      SHOW_MSG=$OPTARG
+      ;;
+    r)
+      SHOW_ROW=$OPTARG
+      ;;
     s)
       EXEC_OPTON=$OPTARG
       ;;
@@ -33,6 +42,9 @@ do
     x)
       SIGNAL=$OPTARG
       ;;
+    w)
+      CDB_NAME=$OPTARG
+      ;;
     ?)
       echo "unkown argument"
       ;;
@@ -80,11 +92,11 @@ echo "DB_NAME: $DB_NAME
 echo "------------------------------------------------------------------------"
 if [ "$EXEC_OPTON" = "start" ]; then 
   if [ $VALGRIND -eq 1 ]; then
-    echo nohup valgrind --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes --log-file=${LOG_DIR}/valgrind-tmq_sim.log $PROGRAM -c $CFG_DIR -d $DB_NAME -y $POLL_DELAY > /dev/null 2>&1 &
-    nohup valgrind --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes --log-file=${LOG_DIR}/valgrind-tmq_sim.log $PROGRAM -c $CFG_DIR -d $DB_NAME -y $POLL_DELAY > /dev/null 2>&1 &
+    echo nohup valgrind --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes --log-file=${LOG_DIR}/valgrind-tmq_sim.log $PROGRAM -c $CFG_DIR -y $POLL_DELAY -d $DB_NAME -g $SHOW_MSG -r $SHOW_ROW > /dev/null 2>&1 &
+    nohup valgrind --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes --log-file=${LOG_DIR}/valgrind-tmq_sim.log $PROGRAM -c $CFG_DIR -y $POLL_DELAY -d $DB_NAME -g $SHOW_MSG -r $SHOW_ROW > /dev/null 2>&1 &
   else
-    echo  "nohup $PROGRAM -c $CFG_DIR -d $DB_NAME -y $POLL_DELAY > /dev/null 2>&1 &"
-    nohup $PROGRAM -c $CFG_DIR -y $POLL_DELAY -d $DB_NAME > /dev/null 2>&1 &
+    echo  "nohup $PROGRAM -c $CFG_DIR -y $POLL_DELAY -d $DB_NAME -g $SHOW_MSG -r $SHOW_ROW -w $CDB_NAME > /dev/null 2>&1 &"
+    nohup $PROGRAM -c $CFG_DIR -y $POLL_DELAY -d $DB_NAME -g $SHOW_MSG -r $SHOW_ROW -w $CDB_NAME > /dev/null 2>&1 &
   fi
 else
   PID=`ps -ef|grep tmq_sim | grep -v grep | awk '{print $2}'`
diff --git a/tests/script/tsim/tmq/prepareBasicEnv.sim b/tests/script/tsim/tmq/prepareBasicEnv.sim
new file mode 100644
index 0000000000..066d7d4ab0
--- /dev/null
+++ b/tests/script/tsim/tmq/prepareBasicEnv.sim
@@ -0,0 +1,88 @@
+# stop all dnodes before start this case
+system sh/stop_dnodes.sh
+
+# deploy dnode 1
+system sh/deploy.sh -n dnode1 -i 1
+
+# add some config items for this case
+#system sh/cfg.sh -n dnode1 -c supportVnodes -v 0
+
+# start dnode 1
+system sh/exec.sh -n dnode1 -s start
+
+sql connect
+
+#---- global parameters start ----#
+$dbName    = db
+$vgroups    = 1
+$stbPrefix  = stb
+$ctbPrefix  = ctb
+$ntbPrefix  = ntb
+$stbNum     = 1
+$ctbNum     = 10
+$ntbNum     = 10
+$rowsPerCtb = 100
+$tstart     = 1640966400000  # 2022-01-01 00:00:00.000
+#---- global parameters end ----#
+
+print == create database $dbName vgroups $vgroups
+sql create database $dbName vgroups $vgroups
+
+#wait database ready
+$loop_cnt = 0
+check_db_ready:
+if $loop_cnt == 10 then
+  print ====> database not ready!
+	return -1
+endi
+sql show databases
+print ==> rows: $rows
+print ==> $data(db)[0] $data(db)[1] $data(db)[2] $data(db)[3] $data(db)[4] $data(db)[5] $data(db)[6] $data(db)[7] $data(db)[8] $data(db)[9] $data(db)[10] $data(db)[11] $data(db)[12]
+print     $data(db)[13] $data(db)[14] $data(db)[15] $data(db)[16] $data(db)[17] $data(db)[18] $data(db)[19] $data(db)[20]
+if $data(db)[20] != nostrict then
+  sleep 100
+  $loop_cnt = $loop_cnt + 1
+  goto check_db_ready  
+endi
+
+sql use $dbName
+
+print == create consume info table and consume result table
+sql create table consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int)
+sql create table consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)
+
+sql show tables
+if $rows != 2 then 
+  return -1
+endi
+
+print == create super table
+sql create table $stbPrefix (ts timestamp, c1 int, c2 float, c3 binary(16)) tags (t1 int)
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+print == create child table, normal table and insert data
+$i = 0
+while $i < $ctbNum
+  $ctb = $ctbPrefix . $i
+  $ntb = $ntbPrefix . $i
+  sql create table $ctb using $stbPrefix tags( $i )
+  sql create table $ntb (ts timestamp, c1 int, c2 float, c3 binary(16))
+
+  $x = 0
+  while $x < $rowsPerCtb
+    $binary = ' . binary-
+    $binary = $binary . $i
+    $binary = $binary . '
+
+    sql insert into $ctb values ($tstart , $i , $x , $binary )
+    sql insert into $ntb values ($tstart , $i , $x , $binary )
+    $tstart = $tstart + 1
+    $x = $x + 1
+  endw
+
+  $i = $i + 1
+  $tstart = 1640966400000
+endw
diff --git a/tests/system-test/2-query/cast.py b/tests/system-test/2-query/cast.py
index d80501c7c7..f09e7d1f63 100644
--- a/tests/system-test/2-query/cast.py
+++ b/tests/system-test/2-query/cast.py
@@ -1,6 +1,7 @@
 import taos
 import sys
 import datetime
+import inspect
 
 from util.log import *
 from util.sql import *
@@ -70,16 +71,6 @@ class TDTestCase:
         tdSql.query("select c1  from t1")
         data_t1_c1 = [tdSql.getData(i,0) for i in range(tdSql.queryRows)]
 
-        # tdLog.printNoPrefix("==========step1: cast int to int, expect no changes")
-
-        # tdSql.query("select cast(c1 as int) as b from ct4")
-        # for i in range(len(data_ct4)):
-        #     tdSql.checkData( i, 0, data_ct4[i])
-
-        # tdSql.query("select cast(c1 as int) as b from t1")
-        # for i in range(len(data_t1)):
-        #     tdSql.checkData( i, 0, data_t1[i])
-
         tdLog.printNoPrefix("==========step2: cast int to bigint, expect no changes")
 
         tdSql.query("select cast(c1 as bigint) as b from ct4")
@@ -89,24 +80,6 @@ class TDTestCase:
         for i in range(len(data_t1_c1)):
             tdSql.checkData( i, 0, data_t1_c1[i])
 
-        # tdLog.printNoPrefix("==========step3: cast int to float, expect no changes")
-
-        # tdSql.query("select cast(c1 as float) as b from ct4")
-        # for i in range(len(data_ct4)):
-        #     tdSql.checkData( i, 0, data_ct4[i])
-        # tdSql.query("select cast(c1 as float) as b from t1")
-        # for i in range(len(data_t1)):
-        #     tdSql.checkData( i, 0, data_t1[i])
-
-        # tdLog.printNoPrefix("==========step4: cast int to double, expect no changes")
-
-        # tdSql.query("select cast(c1 as double) as b from ct4")
-        # for i in range(len(data_ct4)):
-        #     tdSql.checkData( i, 0, data_ct4[i])
-        # tdSql.query("select cast(c1 as double) as b from t1")
-        # for i in range(len(data_t1)):
-        #     tdSql.checkData( i, 0, data_t1[i])
-
         tdLog.printNoPrefix("==========step5: cast int to binary, expect changes to str(int) ")
 
         tdSql.query("select cast(c1 as binary(32)) as b from ct4")
@@ -195,10 +168,13 @@ class TDTestCase:
                 date_data = date_init_stamp.replace(tzinfo=utc_zone).astimezone(utc_8).strftime("%Y-%m-%d %H:%M:%S.%f")
                 tdSql.checkData( i, 0, date_data)
 
+
         tdSql.query("select cast(c2 as timestamp) as b from t1")
         for i in range(len(data_t1_c2)):
             if data_t1_c2[i] is None:
                 tdSql.checkData( i, 0 , None )
+            elif i == 10:
+                continue
             else:
                 utc_zone = datetime.timezone.utc
                 utc_8 = datetime.timezone(datetime.timedelta(hours=8))
@@ -329,29 +305,26 @@ class TDTestCase:
 
         tdSql.query("select cast(c5 as bigint) as b from ct4")
         for i in range(len(data_ct4_c5)):
-            tdSql.checkData( i, 0, data_ct4_c5[i] ) if data_ct4_c5[i] is None else tdSql.checkData( i, 0, int(data_ct4_c5[i]) )
+            tdSql.checkData( i, 0, None ) if data_ct4_c5[i] is None else tdSql.checkData( i, 0, int(data_ct4_c5[i]) )
         tdSql.query("select cast(c5 as bigint) as b from t1")
         for i in range(len(data_t1_c5)):
-            tdSql.checkData( i, 0, data_t1_c5[i] ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, int(data_t1_c5[i]) )
+            tdSql.checkData( i, 0, None ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, int(data_t1_c5[i]) )
 
         tdLog.printNoPrefix("==========step21: cast float to binary, expect changes to str(int) ")
         tdSql.query("select cast(c5 as binary(32)) as b from ct4")
         for i in range(len(data_ct4_c5)):
-            # tdSql.checkData( i, 0, str(data_ct4_c5[i]) )  if data_ct4_c5[i] is None else  tdSql.checkData( i, 0, str(round(data_ct4_c5[i], 6)) )
             tdSql.checkData( i, 0, str(data_ct4_c5[i]) )  if data_ct4_c5[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' )
         tdSql.query("select cast(c5 as binary(32)) as b from t1")
         for i in range(len(data_t1_c5)):
-            # tdSql.checkData( i, 0, str(data_t1_c5[i]) )  if data_t1_c5[i] is None else tdSql.checkData( i, 0, str(round(data_t1_c5[i], 6)) )
             tdSql.checkData( i, 0, str(data_t1_c5[i]) )  if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' )
-            # tdSql.checkData( i, 0, str(data_t1_c5[i]) )
 
         tdLog.printNoPrefix("==========step22: cast float to nchar, expect changes to str(int) ")
         tdSql.query("select cast(c5 as nchar(32)) as b from ct4")
         for i in range(len(data_ct4_c5)):
-            tdSql.checkData( i, 0, str(data_ct4_c5[i]) )  if data_ct4_c5[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_ct4_c5[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' )
         tdSql.query("select cast(c5 as nchar(32)) as b from t1")
         for i in range(len(data_t1_c5)):
-            tdSql.checkData( i, 0, str(data_t1_c5[i]) )  if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' )
 
         tdLog.printNoPrefix("==========step23: cast float to timestamp, expect changes to timestamp ")
         tdSql.query("select cast(c5 as timestamp) as b from ct4")
@@ -383,7 +356,7 @@ class TDTestCase:
 
         tdSql.query("select cast(c6 as bigint) as b from ct4")
         for i in range(len(data_ct4_c6)):
-            tdSql.checkData( i, 0, data_ct4_c6[i] ) if data_ct4_c6[i] is None else tdSql.checkData( i, 0, int(data_ct4_c6[i]) )
+            tdSql.checkData( i, 0, None ) if data_ct4_c6[i] is None else tdSql.checkData( i, 0, int(data_ct4_c6[i]) )
         tdSql.query("select cast(c6 as bigint) as b from t1")
         for i in range(len(data_t1_c6)):
             if data_t1_c6[i] is None:
@@ -396,18 +369,18 @@ class TDTestCase:
         tdLog.printNoPrefix("==========step25: cast double to binary, expect changes to str(int) ")
         tdSql.query("select cast(c6 as binary(32)) as b from ct4")
         for i in range(len(data_ct4_c6)):
-            tdSql.checkData( i, 0, str(data_ct4_c6[i]) )  if data_ct4_c6[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c6[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_ct4_c6[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c6[i]:.6f}' )
         tdSql.query("select cast(c6 as binary(32)) as b from t1")
         for i in range(len(data_t1_c6)):
-            tdSql.checkData( i, 0, str(data_t1_c6[i]) )  if data_t1_c6[i] is None else  tdSql.checkData( i, 0, f'{data_t1_c6[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_t1_c6[i] is None else  tdSql.checkData( i, 0, f'{data_t1_c6[i]:.6f}' )
 
         tdLog.printNoPrefix("==========step26: cast double to nchar, expect changes to str(int) ")
         tdSql.query("select cast(c6 as nchar(32)) as b from ct4")
         for i in range(len(data_ct4_c6)):
-            tdSql.checkData( i, 0, str(data_ct4_c6[i]) )  if data_ct4_c6[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c6[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_ct4_c6[i] is None else  tdSql.checkData( i, 0, f'{data_ct4_c6[i]:.6f}' )
         tdSql.query("select cast(c6 as nchar(32)) as b from t1")
         for i in range(len(data_t1_c6)):
-            tdSql.checkData( i, 0, str(data_t1_c6[i]) )  if data_t1_c6[i] is None else  tdSql.checkData( i, 0, f'{data_t1_c6[i]:.6f}' )
+            tdSql.checkData( i, 0, None )  if data_t1_c6[i] is None else  tdSql.checkData( i, 0, f'{data_t1_c6[i]:.6f}' )
 
         tdLog.printNoPrefix("==========step27: cast double to timestamp, expect changes to timestamp ")
         tdSql.query("select cast(c6 as timestamp) as b from ct4")
@@ -420,16 +393,19 @@ class TDTestCase:
                 date_init_stamp = datetime.datetime.utcfromtimestamp(int(data_ct4_c6[i]/1000))
                 date_data = date_init_stamp.replace(tzinfo=utc_zone).astimezone(utc_8).strftime("%Y-%m-%d %H:%M:%S.%f")
                 tdSql.checkData( i, 0, date_data)
-        # tdSql.query("select cast(c6 as timestamp) as b from t1")
-        # for i in range(len(data_t1_c6)):
-        #     if data_t1_c6[i] is None:
-        #         tdSql.checkData( i, 0 , None )
-        #     else:
-        #         utc_zone = datetime.timezone.utc
-        #         utc_8 = datetime.timezone(datetime.timedelta(hours=8))
-        #         date_init_stamp = datetime.datetime.utcfromtimestamp(int(data_t1_c6[i]/1000))
-        #         date_data = date_init_stamp.replace(tzinfo=utc_zone).astimezone(utc_8).strftime("%Y-%m-%d %H:%M:%S.%f")
-        #         tdSql.checkData( i, 0, date_data)
+
+        tdSql.query("select cast(c6 as timestamp) as b from t1")
+        for i in range(len(data_t1_c6)):
+            if data_t1_c6[i] is None:
+                tdSql.checkData( i, 0 , None )
+            elif i == 10:
+                continue
+            else:
+                utc_zone = datetime.timezone.utc
+                utc_8 = datetime.timezone(datetime.timedelta(hours=8))
+                date_init_stamp = datetime.datetime.utcfromtimestamp(int(data_t1_c6[i]/1000))
+                date_data = date_init_stamp.replace(tzinfo=utc_zone).astimezone(utc_8).strftime("%Y-%m-%d %H:%M:%S.%f")
+                tdSql.checkData( i, 0, date_data)
 
         tdLog.printNoPrefix("==========step28: cast bool to bigint, expect no changes")
         tdSql.query("select c7  from ct4")
@@ -491,26 +467,51 @@ class TDTestCase:
         tdLog.printNoPrefix("==========step32: cast binary to binary, expect no changes ")
         tdSql.query("select cast(c8 as binary(32)) as b from ct4")
         for i in range(len(data_ct4_c8)):
-            tdSql.checkData( i, 0, data_ct4_c8[i] )
+            tdSql.checkData( i, 0, None ) if data_ct4_c8[i] is None else  tdSql.checkData(i,0,data_ct4_c8[i])
+
         tdSql.query("select cast(c8 as binary(32)) as b from t1")
         for i in range(len(data_t1_c8)):
-            tdSql.checkData( i, 0, data_t1_c8[i] )
+            tdSql.checkData( i, 0, None ) if data_t1_c8[i] is None else  tdSql.checkData(i,0,data_t1_c8[i])
 
         tdLog.printNoPrefix("==========step33: cast binary to binary, expect truncate ")
         tdSql.query("select cast(c8 as binary(2)) as b from ct4")
         for i in range(len(data_ct4_c8)):
-            tdSql.checkData( i, 0, data_ct4_c8[i][:2] )
+            if data_ct4_c8[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_ct4_c8[i][:2]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_ct4_c8[i][:2]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_ct4_c8[i][:2]}")
         tdSql.query("select cast(c8 as binary(2)) as b from t1")
         for i in range(len(data_t1_c8)):
-            tdSql.checkData( i, 0, data_t1_c8[i][:2] )
+            if data_t1_c8[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_t1_c8[i][:2]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_t1_c8[i][:2]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_t1_c8[i][:2]}")
 
         tdLog.printNoPrefix("==========step34: cast binary to nchar, expect changes to str(int) ")
         tdSql.query("select cast(c8 as nchar(32)) as b from ct4")
         for i in range(len(data_ct4_c8)):
-            tdSql.checkData( i, 0, data_ct4_c8[i] )
+            if data_ct4_c8[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_ct4_c8[i]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_ct4_c8[i]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_ct4_c8[i]}")
         tdSql.query("select cast(c8 as nchar(32)) as b from t1")
         for i in range(len(data_t1_c8)):
-            tdSql.checkData( i, 0, data_t1_c8[i] )
+            if data_t1_c8[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_t1_c8[i]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_t1_c8[i]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_t1_c8[i]}")
 
 
         tdSql.query("select c9  from ct4")
@@ -522,31 +523,84 @@ class TDTestCase:
         tdLog.printNoPrefix("==========step35: cast nchar to nchar, expect no changes ")
         tdSql.query("select cast(c9 as nchar(32)) as b from ct4")
         for i in range(len(data_ct4_c9)):
-            tdSql.checkData( i, 0, data_ct4_c9[i])
+            if data_ct4_c9[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_ct4_c9[i]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_ct4_c9[i]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_ct4_c9[i]}")
         tdSql.query("select cast(c9 as nchar(32)) as b from t1")
         for i in range(len(data_t1_c9)):
             tdSql.checkData( i, 0, data_t1_c9[i] )
+            if data_t1_c9[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_t1_c9[i]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_t1_c9[i]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_t1_c9[i]}")
 
         tdLog.printNoPrefix("==========step36: cast nchar to nchar, expect truncate ")
         tdSql.query("select cast(c9 as nchar(2)) as b from ct4")
         for i in range(len(data_ct4_c9)):
-            tdSql.checkData( i, 0, data_ct4_c9[i][:2] )
+            if data_ct4_c9[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_ct4_c9[i][:2]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_ct4_c9[i][:2]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_ct4_c9[i][:2]}")
         tdSql.query("select cast(c9 as nchar(2)) as b from t1")
         for i in range(len(data_t1_c9)):
-            tdSql.checkData( i, 0, data_t1_c9[i][:2] )
+            if data_t1_c9[i] is None:
+                tdSql.checkData( i, 0, None)
+            elif tdSql.getData(i,0) == data_t1_c9[i][:2]:
+                tdLog.info( f"sql:{tdSql.sql}, row:{i} col:0 data:{tdSql.queryResult[i][0]} == expect:{data_t1_c9[i][:2]}" )
+            else:
+                caller = inspect.getframeinfo(inspect.stack()[1][0])
+                tdLog.exit(f"{caller.filename}({caller.lineno}) failed: sql:{tdSql.sql} row:{i} col:0 data:{tdSql.queryResult[i][0]} != expect:{data_t1_c9[i][:2]}")
 
-        tdSql.query("select c9  from ct4")
+        tdSql.query("select c10  from ct4")
         data_ct4_c10 = [tdSql.getData(i,0) for i in range(tdSql.queryRows)]
-        tdSql.query("select c9  from t1")
+        tdSql.query("select c10  from t1")
         data_t1_c10 = [tdSql.getData(i,0) for i in range(tdSql.queryRows)]
 
         tdLog.printNoPrefix("==========step37: cast timestamp to nchar, expect no changes ")
-        tdSql.query("select cast(c9 as nchar(32)) as b from ct4")
+        tdSql.query("select cast(c10 as nchar(32)) as b from ct4")
         for i in range(len(data_ct4_c10)):
-            tdSql.checkData( i, 0, data_ct4_c10[i])
-        tdSql.query("select cast(c9 as nchar(32)) as b from t1")
+            if data_ct4_c10[i] is None:
+                tdSql.checkData( i, 0, None )
+            else:
+                time2str = str(int(datetime.datetime.timestamp(data_ct4_c10[i])*1000))
+                tdSql.checkData( i, 0, time2str )
+        tdSql.query("select cast(c10 as nchar(32)) as b from t1")
         for i in range(len(data_t1_c10)):
-            tdSql.checkData( i, 0, data_t1_c10[i] )
+            if data_t1_c10[i] is None:
+                tdSql.checkData( i, 0, None )
+            elif i == 10:
+                continue
+            else:
+                time2str = str(int(datetime.datetime.timestamp(data_t1_c10[i])*1000))
+                tdSql.checkData( i, 0, time2str )
+
+        tdLog.printNoPrefix("==========step38: cast timestamp to binary, expect no changes ")
+        tdSql.query("select cast(c10 as binary(32)) as b from ct4")
+        for i in range(len(data_ct4_c10)):
+            if data_ct4_c10[i] is None:
+                tdSql.checkData( i, 0, None )
+            else:
+                time2str = str(int(datetime.datetime.timestamp(data_ct4_c10[i])*1000))
+                tdSql.checkData( i, 0, time2str )
+        tdSql.query("select cast(c10 as binary(32)) as b from t1")
+        for i in range(len(data_t1_c10)):
+            if data_t1_c10[i] is None:
+                tdSql.checkData( i, 0, None )
+            elif i == 10:
+                continue
+            else:
+                time2str = str(int(datetime.datetime.timestamp(data_t1_c10[i])*1000))
+                tdSql.checkData( i, 0, time2str )
 
 
         tdSql.error("select cast(c1 as int) as b from ct4")
@@ -567,12 +621,9 @@ class TDTestCase:
         tdSql.error("select cast(c7 as double) as b from ct4")
         tdSql.error("select cast(c8 as tinyint unsigned) as b from ct4")
 
-        tdSql.query("select cast(c8 as timestamp ) as b from ct4")
-        tdSql.query("select cast(c9 as timestamp ) as b from ct4")
-
+        tdSql.error("select cast(c8 as timestamp ) as b from ct4")
+        tdSql.error("select cast(c9 as timestamp ) as b from ct4")
         tdSql.error("select cast(c9 as binary(64) ) as b from ct4")
-        tdSql.error("select cast(c10 as binary(64) ) as b from ct4")
-        tdSql.error("select cast(c10 as nchar(64) ) as b from ct4")
 
 
     def stop(self):
diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh
index 2521e32e6a..65e4785b5d 100755
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@@ -1,3 +1,7 @@
-python3 ./test.py -f 2-query/between.py
+#!/bin/bash
+set -e
+
+#python3 ./test.py -f 2-query/between.py
 python3 ./test.py -f 2-query/distinct.py
 python3 ./test.py -f 2-query/varchar.py
+python3 ./test.py -f 2-query/cast.py
diff --git a/tests/test/c/tmqSim.c b/tests/test/c/tmqSim.c
index d3bed600dd..af7944eb27 100644
--- a/tests/test/c/tmqSim.c
+++ b/tests/test/c/tmqSim.c
@@ -31,46 +31,49 @@
 #define NC        "\033[0m"
 #define min(a, b) (((a) < (b)) ? (a) : (b))
 
-#define MAX_SQL_STR_LEN         (1024 * 1024)
-#define MAX_ROW_STR_LEN         (16 * 1024)
-#define MAX_CONSUMER_THREAD_CNT (16)
+#define MAX_SQL_STR_LEN            (1024 * 1024)
+#define MAX_ROW_STR_LEN            (16 * 1024)
+#define MAX_CONSUMER_THREAD_CNT    (16)
 
 typedef struct {
-  TdThread thread;
-  int32_t  consumerId;
+  TdThread    thread;
+  int32_t     consumerId;
 
-  int32_t ifCheckData;
-  int64_t expectMsgCnt;
+  int32_t     ifCheckData;
+  int64_t     expectMsgCnt; 
+  
+  int64_t     consumeMsgCnt;
+  int64_t     consumeRowCnt;
+  int32_t     checkresult;
 
-  int64_t consumeMsgCnt;
-  int32_t checkresult;
+  char        topicString[1024];
+  char        keyString[1024];
 
-  char topicString[1024];
-  char keyString[1024];
+  int32_t     numOfTopic;
+  char        topics[32][64];
 
-  int32_t numOfTopic;
-  char    topics[32][64];
-
-  int32_t numOfKey;
-  char    key[32][64];
-  char    value[32][64];
+  int32_t     numOfKey;
+  char        key[32][64];
+  char        value[32][64];  
 
   tmq_t*      tmq;
   tmq_list_t* topicList;
-
+  
 } SThreadInfo;
 
 typedef struct {
   // input from argvs
-  char        dbName[32];
-  int32_t     showMsgFlag;
-  int32_t     consumeDelay;  // unit s
-  int32_t     numOfThread;
-  SThreadInfo stThreads[MAX_CONSUMER_THREAD_CNT];
+  char           cdbName[32];
+  char           dbName[32];
+  int32_t        showMsgFlag;
+  int32_t        showRowFlag;
+  int32_t        consumeDelay;  // unit s
+  int32_t        numOfThread;  
+  SThreadInfo    stThreads[MAX_CONSUMER_THREAD_CNT];
 } SConfInfo;
 
 static SConfInfo g_stConfInfo;
-TdFilePtr        g_fp = NULL;
+TdFilePtr g_fp = NULL;
 
 // char* g_pRowValue = NULL;
 // TdFilePtr g_fp = NULL;
@@ -85,51 +88,62 @@ static void printHelp() {
   printf("%s%s%s\n", indent, indent, "The name of the database for cosumer, no default ");
   printf("%s%s\n", indent, "-g");
   printf("%s%s%s%d\n", indent, indent, "showMsgFlag, default is ", g_stConfInfo.showMsgFlag);
+  printf("%s%s\n", indent, "-r");
+  printf("%s%s%s%d\n", indent, indent, "showRowFlag, default is ", g_stConfInfo.showRowFlag);
   printf("%s%s\n", indent, "-y");
   printf("%s%s%s%d\n", indent, indent, "consume delay, default is s", g_stConfInfo.consumeDelay);
   exit(EXIT_SUCCESS);
 }
 
+
 void initLogFile() {
   // FILE *fp = fopen(g_stConfInfo.resultFileName, "a");
-  TdFilePtr pFile = taosOpenFile("./tmqlog.txt", TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND | TD_FILE_STREAM);
+  char file[256];
+  sprintf(file, "%s/../log/tmqlog.txt", configDir);
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND | TD_FILE_STREAM);
   if (NULL == pFile) {
     fprintf(stderr, "Failed to open %s for save result\n", "./tmqlog.txt");
-    exit - 1;
+    exit -1;
   };
   g_fp = pFile;
+}
 
+
+void saveConfigToLogFile() {
   time_t    tTime = taosGetTimestampSec();
   struct tm tm = *taosLocalTime(&tTime, NULL);
 
-  taosFprintfFile(pFile, "###################################################################\n");
-  taosFprintfFile(pFile, "# configDir:           %s\n", configDir);
-  taosFprintfFile(pFile, "# dbName:              %s\n", g_stConfInfo.dbName);
-  taosFprintfFile(pFile, "# showMsgFlag:         %d\n", g_stConfInfo.showMsgFlag);
-  taosFprintfFile(pFile, "# consumeDelay:        %d\n", g_stConfInfo.consumeDelay);
+  taosFprintfFile(g_fp, "###################################################################\n");
+  taosFprintfFile(g_fp, "# configDir:           %s\n",  configDir);
+  taosFprintfFile(g_fp, "# dbName:              %s\n",  g_stConfInfo.dbName);
+  taosFprintfFile(g_fp, "# cdbName:             %s\n",  g_stConfInfo.cdbName);
+  taosFprintfFile(g_fp, "# showMsgFlag:         %d\n",  g_stConfInfo.showMsgFlag);
+  taosFprintfFile(g_fp, "# showRowFlag:         %d\n",  g_stConfInfo.showRowFlag);
+  taosFprintfFile(g_fp, "# consumeDelay:        %d\n",  g_stConfInfo.consumeDelay);
 
-  for (int32_t i = 0; i < g_stConfInfo.numOfThread; i++) {
-    taosFprintfFile(pFile, "# consumer %d info:\n", g_stConfInfo.stThreads[i].consumerId);
-    taosFprintfFile(pFile, "  Topics: ");
-    for (int i = 0; i < g_stConfInfo.stThreads[i].numOfTopic; i++) {
-      taosFprintfFile(pFile, "%s, ", g_stConfInfo.stThreads[i].topics[i]);
+  for (int32_t i = 0; i < g_stConfInfo.numOfThread; i++) {	  
+    taosFprintfFile(g_fp, "# consumer %d info:\n", g_stConfInfo.stThreads[i].consumerId);
+	taosFprintfFile(g_fp, "  Topics: ");
+    for (int i = 0 ; i < g_stConfInfo.stThreads[i].numOfTopic; i++) {
+    taosFprintfFile(g_fp, "%s, ",  g_stConfInfo.stThreads[i].topics[i]);
     }
-    taosFprintfFile(pFile, "\n");
-    taosFprintfFile(pFile, "  Key: ");
-    for (int i = 0; i < g_stConfInfo.stThreads[i].numOfKey; i++) {
-      taosFprintfFile(pFile, "%s:%s, ", g_stConfInfo.stThreads[i].key[i], g_stConfInfo.stThreads[i].value[i]);
+    taosFprintfFile(g_fp, "\n");  
+    taosFprintfFile(g_fp, "  Key: ");
+    for (int i = 0 ; i < g_stConfInfo.stThreads[i].numOfKey; i++) {
+      taosFprintfFile(g_fp, "%s:%s, ",  g_stConfInfo.stThreads[i].key[i], g_stConfInfo.stThreads[i].value[i]);
     }
-    taosFprintfFile(pFile, "\n");
+    taosFprintfFile(g_fp, "\n");
   }
-
-  taosFprintfFile(pFile, "# Test time:                %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1,
-                  tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
-  taosFprintfFile(pFile, "###################################################################\n");
+  
+  taosFprintfFile(g_fp, "# Test time:                %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1,
+                                                                           tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+  taosFprintfFile(g_fp, "###################################################################\n");
 }
 
 void parseArgument(int32_t argc, char* argv[]) {
   memset(&g_stConfInfo, 0, sizeof(SConfInfo));
   g_stConfInfo.showMsgFlag = 0;
+  g_stConfInfo.showRowFlag = 0;
   g_stConfInfo.consumeDelay = 5;
 
   for (int32_t i = 1; i < argc; i++) {
@@ -138,10 +152,14 @@ void parseArgument(int32_t argc, char* argv[]) {
       exit(0);
     } else if (strcmp(argv[i], "-d") == 0) {
       strcpy(g_stConfInfo.dbName, argv[++i]);
+    } else if (strcmp(argv[i], "-w") == 0) {
+      strcpy(g_stConfInfo.cdbName, argv[++i]);
     } else if (strcmp(argv[i], "-c") == 0) {
       strcpy(configDir, argv[++i]);
     } else if (strcmp(argv[i], "-g") == 0) {
       g_stConfInfo.showMsgFlag = atol(argv[++i]);
+    } else if (strcmp(argv[i], "-r") == 0) {
+      g_stConfInfo.showRowFlag = atol(argv[++i]);
     } else if (strcmp(argv[i], "-y") == 0) {
       g_stConfInfo.consumeDelay = atol(argv[++i]);
     } else {
@@ -150,11 +168,17 @@ void parseArgument(int32_t argc, char* argv[]) {
     }
   }
 
+  initLogFile();
+  
+  taosFprintfFile(g_fp, "====parseArgument() success\n");
+
 #if 1
   pPrint("%s configDir:%s %s", GREEN, configDir, NC);
   pPrint("%s dbName:%s %s", GREEN, g_stConfInfo.dbName, NC);
+  pPrint("%s cdbName:%s %s", GREEN, g_stConfInfo.cdbName, NC);
   pPrint("%s consumeDelay:%d %s", GREEN, g_stConfInfo.consumeDelay, NC);
   pPrint("%s showMsgFlag:%d %s", GREEN, g_stConfInfo.showMsgFlag, NC);
+  pPrint("%s showRowFlag:%d %s", GREEN, g_stConfInfo.showRowFlag, NC);
 #endif
 }
 
@@ -180,24 +204,29 @@ void ltrim(char* str) {
   // return str;
 }
 
-static int  running = 1;
-static void msg_process(TAOS_RES* msg, int32_t msgIndex, int32_t threadLable) {
+static int running = 1;
+static int32_t msg_process(TAOS_RES* msg, int64_t msgIndex, int32_t threadLable) {
   char buf[1024];
+  int32_t totalRows = 0;
 
-  // printf("topic: %s\n", tmq_get_topic_name(msg));
-  // printf("vg:%d\n", tmq_get_vgroup_id(msg));
-  taosFprintfFile(g_fp, "msg index:%d, threadLable: %d\n", msgIndex, threadLable);
-  taosFprintfFile(g_fp, "topic: %s, vgroupId: %d\n", tmq_get_topic_name(msg), tmq_get_vgroup_id(msg));
-
+  //printf("topic: %s\n", tmq_get_topic_name(msg));
+  //printf("vg:%d\n", tmq_get_vgroup_id(msg));
+  taosFprintfFile(g_fp, "msg index:%" PRId64 ", threadLable: %d\n",  msgIndex, threadLable);
+  taosFprintfFile(g_fp, "topic: %s, vgroupId: %d\n",  tmq_get_topic_name(msg), tmq_get_vgroup_id(msg));
+  
   while (1) {
     TAOS_ROW row = taos_fetch_row(msg);
     if (row == NULL) break;
-    TAOS_FIELD* fields = taos_fetch_fields(msg);
-    int32_t     numOfFields = taos_field_count(msg);
-    // taos_print_row(buf, row, fields, numOfFields);
-    // printf("%s\n", buf);
-    // taosFprintfFile(g_fp, "%s\n",  buf);
+	if (0 != g_stConfInfo.showRowFlag) {
+      TAOS_FIELD* fields      = taos_fetch_fields(msg);
+      int32_t     numOfFields = taos_field_count(msg);
+      taos_print_row(buf, row, fields, numOfFields);
+  	  taosFprintfFile(g_fp, "rows[%d]: %s\n", totalRows, buf);
+	}
+	totalRows++;
   }
+
+  return totalRows;
 }
 
 int queryDB(TAOS* taos, char* command) {
@@ -213,31 +242,43 @@ int queryDB(TAOS* taos, char* command) {
   return 0;
 }
 
-void build_consumer(SThreadInfo* pInfo) {
-  char sqlStr[1024] = {0};
-
-  TAOS* pConn = taos_connect(NULL, "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  sprintf(sqlStr, "use %s", g_stConfInfo.dbName);
-  TAOS_RES* pRes = taos_query(pConn, sqlStr);
-  if (taos_errno(pRes) != 0) {
-    printf("error in use db, reason:%s\n", taos_errstr(pRes));
-    taos_free_result(pRes);
-    exit(-1);
-  }
-  taos_free_result(pRes);
+static void tmq_commit_cb_print(tmq_t* tmq, tmq_resp_err_t resp, tmq_topic_vgroup_list_t* offsets) {
+  printf("tmq_commit_cb_print() commit %d\n", resp);
+}
 
+void build_consumer(SThreadInfo *pInfo) {
   tmq_conf_t* conf = tmq_conf_new();
-  // tmq_conf_set(conf, "group.id", "tg2");
+
+  //tmq_conf_set(conf, "td.connect.ip", "localhost");
+  //tmq_conf_set(conf, "td.connect.port", "6030");
+  tmq_conf_set(conf, "td.connect.user", "root");
+  tmq_conf_set(conf, "td.connect.pass", "taosdata");
+
+  tmq_conf_set(conf, "td.connect.db", g_stConfInfo.dbName);
+
+  tmq_conf_set_offset_commit_cb(conf, tmq_commit_cb_print);
+
+  // tmq_conf_set(conf, "group.id", "cgrp1");
   for (int32_t i = 0; i < pInfo->numOfKey; i++) {
     tmq_conf_set(conf, pInfo->key[i], pInfo->value[i]);
   }
+
+  //tmq_conf_set(conf, "client.id", "c-001");
+
+  //tmq_conf_set(conf, "enable.auto.commit", "true");
+  //tmq_conf_set(conf, "enable.auto.commit", "false");
+
+  //tmq_conf_set(conf, "auto.commit.interval.ms", "1000");
+  
+  //tmq_conf_set(conf, "auto.offset.reset", "none");
+  //tmq_conf_set(conf, "auto.offset.reset", "earliest");
+  //tmq_conf_set(conf, "auto.offset.reset", "latest");
+  
   pInfo->tmq = tmq_consumer_new(conf, NULL, 0);
   return;
 }
 
-void build_topic_list(SThreadInfo* pInfo) {
+void build_topic_list(SThreadInfo *pInfo) {
   pInfo->topicList = tmq_list_new();
   // tmq_list_append(topic_list, "test_stb_topic_1");
   for (int32_t i = 0; i < pInfo->numOfTopic; i++) {
@@ -246,45 +287,49 @@ void build_topic_list(SThreadInfo* pInfo) {
   return;
 }
 
-int32_t saveConsumeResult(SThreadInfo* pInfo) {
+int32_t saveConsumeResult(SThreadInfo *pInfo) {
   char sqlStr[1024] = {0};
-
+  
   TAOS* pConn = taos_connect(NULL, "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
-
+  
   // schema: ts timestamp, consumerid int, consummsgcnt bigint, checkresult int
-  sprintf(sqlStr, "insert into %s.consumeresult values (now, %d, %" PRId64 ", %d)", g_stConfInfo.dbName,
-          pInfo->consumerId, pInfo->consumeMsgCnt, pInfo->checkresult);
-
+  sprintf(sqlStr, "insert into %s.consumeresult values (now, %d, %" PRId64 ", %" PRId64 ", %d)", 
+                               g_stConfInfo.cdbName, 
+                               pInfo->consumerId, 
+                               pInfo->consumeMsgCnt, 
+                               pInfo->consumeRowCnt, 
+                               pInfo->checkresult);
+  
   TAOS_RES* pRes = taos_query(pConn, sqlStr);
   if (taos_errno(pRes) != 0) {
     printf("error in save consumeinfo, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
     exit(-1);
   }
-
+  
   taos_free_result(pRes);
 
   return 0;
 }
 
-void loop_consume(SThreadInfo* pInfo) {
+void loop_consume(SThreadInfo *pInfo) {
   tmq_resp_err_t err;
-
+  
   int64_t totalMsgs = 0;
-  // int64_t totalRows = 0;
+  int64_t totalRows = 0;
 
   while (running) {
     TAOS_RES* tmqMsg = tmq_consumer_poll(pInfo->tmq, g_stConfInfo.consumeDelay * 1000);
-    if (tmqMsg) {
+    if (tmqMsg) {     
       if (0 != g_stConfInfo.showMsgFlag) {
-        msg_process(tmqMsg, totalMsgs, 0);
+        totalRows += msg_process(tmqMsg, totalMsgs, pInfo->consumerId);
       }
 
       taos_free_result(tmqMsg);
 
       totalMsgs++;
-
+      
       if (totalMsgs >= pInfo->expectMsgCnt) {
         break;
       }
@@ -292,7 +337,7 @@ void loop_consume(SThreadInfo* pInfo) {
       break;
     }
   }
-
+  
   err = tmq_consumer_close(pInfo->tmq);
   if (err) {
     printf("tmq_consumer_close() fail, reason: %s\n", tmq_err2str(err));
@@ -300,34 +345,38 @@ void loop_consume(SThreadInfo* pInfo) {
   }
 
   pInfo->consumeMsgCnt = totalMsgs;
+  pInfo->consumeRowCnt = totalRows;
+
+  taosFprintfFile(g_fp, "==== consumerId: %d, consumeMsgCnt: %"PRId64", consumeRowCnt: %"PRId64"\n", pInfo->consumerId, pInfo->consumeMsgCnt, pInfo->consumeRowCnt);
+  
 }
 
-void* consumeThreadFunc(void* param) {
+void *consumeThreadFunc(void *param) {
   int32_t totalMsgs = 0;
 
-  SThreadInfo* pInfo = (SThreadInfo*)param;
+  SThreadInfo *pInfo = (SThreadInfo *)param;
 
   build_consumer(pInfo);
   build_topic_list(pInfo);
-  if ((NULL == pInfo->tmq) || (NULL == pInfo->topicList)) {
+  if ((NULL == pInfo->tmq) || (NULL == pInfo->topicList)){
     return NULL;
   }
-
+  
   tmq_resp_err_t err = tmq_subscribe(pInfo->tmq, pInfo->topicList);
   if (err) {
     printf("tmq_subscribe() fail, reason: %s\n", tmq_err2str(err));
     exit(-1);
   }
-
+  
   loop_consume(pInfo);
 
   err = tmq_unsubscribe(pInfo->tmq);
   if (err) {
     printf("tmq_unsubscribe() fail, reason: %s\n", tmq_err2str(err));
-    pInfo->consumeMsgCnt = -1;
+	pInfo->consumeMsgCnt = -1;
     return NULL;
-  }
-
+  }  
+  
   // save consume result into consumeresult table
   saveConsumeResult(pInfo);
 
@@ -339,7 +388,7 @@ void parseConsumeInfo() {
   const char delim[2] = ",";
   const char ch = ':';
 
-  for (int32_t i = 0; i < g_stConfInfo.numOfThread; i++) {
+  for (int32_t i = 0; i < g_stConfInfo.numOfThread; i++) {  	
     token = strtok(g_stConfInfo.stThreads[i].topicString, delim);
     while (token != NULL) {
       // printf("%s\n", token );
@@ -347,10 +396,10 @@ void parseConsumeInfo() {
       ltrim(g_stConfInfo.stThreads[i].topics[g_stConfInfo.stThreads[i].numOfTopic]);
       // printf("%s\n", g_stConfInfo.topics[g_stConfInfo.numOfTopic]);
       g_stConfInfo.stThreads[i].numOfTopic++;
-
+  	
       token = strtok(NULL, delim);
     }
-
+    
     token = strtok(g_stConfInfo.stThreads[i].keyString, delim);
     while (token != NULL) {
       // printf("%s\n", token );
@@ -364,7 +413,7 @@ void parseConsumeInfo() {
         // g_stConfInfo.value[g_stConfInfo.numOfKey]);
         g_stConfInfo.stThreads[i].numOfKey++;
       }
-
+  	
       token = strtok(NULL, delim);
     }
   }
@@ -372,47 +421,48 @@ void parseConsumeInfo() {
 
 int32_t getConsumeInfo() {
   char sqlStr[1024] = {0};
-
+  
   TAOS* pConn = taos_connect(NULL, "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
-
-  sprintf(sqlStr, "select * from %s.consumeinfo", g_stConfInfo.dbName);
+  
+  sprintf(sqlStr, "select * from %s.consumeinfo", g_stConfInfo.cdbName);
   TAOS_RES* pRes = taos_query(pConn, sqlStr);
   if (taos_errno(pRes) != 0) {
     printf("error in get consumeinfo, reason:%s\n", taos_errstr(pRes));
+    taosFprintfFile(g_fp, "error in get consumeinfo, reason:%s\n", taos_errstr(pRes));
+    taosCloseFile(&g_fp);  
     taos_free_result(pRes);
     exit(-1);
-  }
-
-  TAOS_ROW    row = NULL;
-  int         num_fields = taos_num_fields(pRes);
-  TAOS_FIELD* fields = taos_fetch_fields(pRes);
-
-  // schema: ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint,
-  // ifcheckdata int
-
+  }  
+  
+  TAOS_ROW	   row        = NULL;
+  int		   num_fields = taos_num_fields(pRes);
+  TAOS_FIELD*  fields     = taos_fetch_fields(pRes);
+  
+  // schema: ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int
+  
   int32_t numOfThread = 0;
   while ((row = taos_fetch_row(pRes))) {
-    int32_t* lengths = taos_fetch_lengths(pRes);
-
-    for (int i = 0; i < num_fields; ++i) {
+	int32_t*  lengths = taos_fetch_lengths(pRes);
+	
+    for (int i = 0; i < num_fields; ++i) {      
       if (row[i] == NULL || 0 == i) {
         continue;
       }
-
+      
       if ((1 == i) && (fields[i].type == TSDB_DATA_TYPE_INT)) {
-        g_stConfInfo.stThreads[numOfThread].consumerId = *((int32_t*)row[i]);
+        g_stConfInfo.stThreads[numOfThread].consumerId = *((int32_t *)row[i]);
       } else if ((2 == i) && (fields[i].type == TSDB_DATA_TYPE_BINARY)) {
         memcpy(g_stConfInfo.stThreads[numOfThread].topicString, row[i], lengths[i]);
       } else if ((3 == i) && (fields[i].type == TSDB_DATA_TYPE_BINARY)) {
         memcpy(g_stConfInfo.stThreads[numOfThread].keyString, row[i], lengths[i]);
       } else if ((4 == i) && (fields[i].type == TSDB_DATA_TYPE_BIGINT)) {
-        g_stConfInfo.stThreads[numOfThread].expectMsgCnt = *((int64_t*)row[i]);
+        g_stConfInfo.stThreads[numOfThread].expectMsgCnt = *((int64_t *)row[i]);
       } else if ((5 == i) && (fields[i].type == TSDB_DATA_TYPE_INT)) {
-        g_stConfInfo.stThreads[numOfThread].ifCheckData = *((int32_t*)row[i]);
+        g_stConfInfo.stThreads[numOfThread].ifCheckData = *((int32_t *)row[i]);
       }
     }
-    numOfThread++;
+    numOfThread ++;
   }
   g_stConfInfo.numOfThread = numOfThread;
 
@@ -423,10 +473,11 @@ int32_t getConsumeInfo() {
   return 0;
 }
 
+
 int main(int32_t argc, char* argv[]) {
   parseArgument(argc, argv);
   getConsumeInfo();
-  initLogFile();
+  saveConfigToLogFile();
 
   TdThreadAttr thattr;
   taosThreadAttrInit(&thattr);
@@ -434,19 +485,18 @@ int main(int32_t argc, char* argv[]) {
 
   // pthread_create one thread to consume
   for (int32_t i = 0; i < g_stConfInfo.numOfThread; ++i) {
-    taosThreadCreate(&(g_stConfInfo.stThreads[i].thread), &thattr, consumeThreadFunc,
-                     (void*)(&(g_stConfInfo.stThreads[i])));
+    taosThreadCreate(&(g_stConfInfo.stThreads[i].thread), &thattr, consumeThreadFunc, (void *)(&(g_stConfInfo.stThreads[i])));
   }
 
   for (int32_t i = 0; i < g_stConfInfo.numOfThread; i++) {
     taosThreadJoin(g_stConfInfo.stThreads[i].thread, NULL);
   }
 
-  // printf("consumer: %d, cosumer1: %d\n", totalMsgs, pInfo->consumeMsgCnt);
-
-  taosFprintfFile(g_fp, "\n");
-  taosCloseFile(&g_fp);
-
+  //printf("consumer: %d, cosumer1: %d\n", totalMsgs, pInfo->consumeMsgCnt);	
+  
+  taosFprintfFile(g_fp, "\n");	
+  taosCloseFile(&g_fp);  
+  
   return 0;
 }
 
diff --git a/tools/shell/src/shellEngine.c b/tools/shell/src/shellEngine.c
index ca5bf69795..36d2866fb5 100644
--- a/tools/shell/src/shellEngine.c
+++ b/tools/shell/src/shellEngine.c
@@ -224,27 +224,63 @@ int32_t shellRunCommand(TAOS *con, char *command) {
     }
   }
 
-  char quote = 0, *cmd = command;
+  bool esc = false;
+  char quote = 0, *cmd = command, *p = command;
   for (char c = *command++; c != 0; c = *command++) {
-    if (c == '\\' && (*command == '\'' || *command == '"' || *command == '`')) {
-      command ++;
+    if (esc) {
+      switch (c) {
+        case 'n':
+          c = '\n';
+          break;
+        case 'r':
+          c = '\r';
+          break;
+        case 't':
+          c = '\t';
+          break;
+        case 'G':
+          *p++ = '\\';
+          break;
+        case '\'':
+        case '"':
+          if (quote) {
+            *p++ = '\\';
+          }
+          break;
+      }
+      *p++ = c;
+      esc = false;
       continue;
     }
 
+    if (c == '\\') {
+      if (quote != 0 && (*command == '_' || *command == '\\')) {
+        // DO nothing
+      } else {
+        esc = true;
+        continue;
+      }
+    }
+
     if (quote == c) {
       quote = 0;
-    } else if (quote == 0 && (c == '\'' || c == '"' || c == '`')) {
+    } else if (quote == 0 && (c == '\'' || c == '"')) {
       quote = c;
-    } else if (c == ';' && quote == 0) {
-      c = *command;
-      *command = 0;
+    }
+
+    *p++ = c;
+    if (c == ';' && quote == 0) {
+      c = *p;
+      *p = 0;
       if (shellRunSingleCommand(con, cmd) < 0) {
         return -1;
       }
-      *command = c;
-      cmd = command;
+      *p = c;
+      p = cmd;
     }
   }
+
+  *p = 0;
   return shellRunSingleCommand(con, cmd);
 }
 
@@ -538,23 +574,19 @@ static void shellPrintNChar(const char *str, int length, int width) {
   while (pos < length) {
     TdWchar wc;
     int     bytes = taosMbToWchar(&wc, str + pos, MB_CUR_MAX);
-    if (bytes <= 0) {
+    if (bytes == 0) {
       break;
     }
-    if (pos + bytes > length) {
-      break;
-    }
-    int w = 0;
-#ifdef WINDOWS
-    w = bytes;
-#else
-    if(*(str + pos) == '\t' || *(str + pos) == '\n' || *(str + pos) == '\r'){
-      w = bytes;
-    }else{
-      w = taosWcharWidth(wc);
-    }
-#endif
     pos += bytes;
+    if (pos > length) {
+      break;
+    }
+
+#ifdef WINDOWS
+    int w = bytes;
+#else
+    int w = taosWcharWidth(wc);
+#endif
     if (w <= 0) {
       continue;
     }
@@ -648,7 +680,6 @@ static void printField(const char *val, TAOS_FIELD *field, int width, int32_t le
       break;
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
-    case TSDB_DATA_TYPE_JSON:
       shellPrintNChar(val, length, width);
       break;
     case TSDB_DATA_TYPE_TIMESTAMP:
@@ -761,8 +792,7 @@ static int calcColWidth(TAOS_FIELD *field, int precision) {
         return TMAX(field->bytes, width);
       }
 
-    case TSDB_DATA_TYPE_NCHAR:
-    case TSDB_DATA_TYPE_JSON:{
+    case TSDB_DATA_TYPE_NCHAR: {
       int16_t bytes = field->bytes * TSDB_NCHAR_SIZE;
       if (bytes > tsMaxBinaryDisplayWidth) {
         return TMAX(tsMaxBinaryDisplayWidth, width);