diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 23945cd500..4a3c4b0c3f 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -1315,6 +1315,31 @@ typedef struct {
 int32_t tSerializeSKillTransReq(void* buf, int32_t bufLen, SKillTransReq* pReq);
 int32_t tDeserializeSKillTransReq(void* buf, int32_t bufLen, SKillTransReq* pReq);
 
+typedef struct {
+  int32_t useless;  // useless
+} SBalanceVgroupReq;
+
+int32_t tSerializeSBalanceVgroupReq(void* buf, int32_t bufLen, SBalanceVgroupReq* pReq);
+int32_t tDeserializeSBalanceVgroupReq(void* buf, int32_t bufLen, SBalanceVgroupReq* pReq);
+
+typedef struct {
+  int32_t vgId1;
+  int32_t vgId2;
+} SMergeVgroupReq;
+
+int32_t tSerializeSMergeVgroupReq(void* buf, int32_t bufLen, SMergeVgroupReq* pReq);
+int32_t tDeserializeSMergeVgroupReq(void* buf, int32_t bufLen, SMergeVgroupReq* pReq);
+
+typedef struct {
+  int32_t vgId;
+  int32_t dnodeId1;
+  int32_t dnodeId2;
+  int32_t dnodeId3;
+} SRedistributeVgroupReq;
+
+int32_t tSerializeSRedistributeVgroupReq(void* buf, int32_t bufLen, SRedistributeVgroupReq* pReq);
+int32_t tDeserializeSRedistributeVgroupReq(void* buf, int32_t bufLen, SRedistributeVgroupReq* pReq);
+
 typedef struct {
   char user[TSDB_USER_LEN];
   char spi;
@@ -2460,6 +2485,32 @@ typedef struct {
 int32_t tSerializeSUserIndexRsp(void* buf, int32_t bufLen, const SUserIndexRsp* pRsp);
 int32_t tDeserializeSUserIndexRsp(void* buf, int32_t bufLen, SUserIndexRsp* pRsp);
 
+typedef struct {
+  char tbFName[TSDB_TABLE_FNAME_LEN];
+} STableIndexReq;
+
+int32_t tSerializeSTableIndexReq(void* buf, int32_t bufLen, STableIndexReq* pReq);
+int32_t tDeserializeSTableIndexReq(void* buf, int32_t bufLen, STableIndexReq* pReq);
+
+typedef struct {
+  int8_t    intervalUnit;
+  int8_t    slidingUnit;
+  int64_t   interval;
+  int64_t   offset;
+  int64_t   sliding;
+  int64_t   dstTbUid;  
+  int32_t   dstVgId;  // for stream  
+  char*     expr;
+} STableIndexInfo;
+
+typedef struct {
+  SArray* pIndex;
+} STableIndexRsp;
+
+int32_t tSerializeSTableIndexRsp(void* buf, int32_t bufLen, const STableIndexRsp* pRsp);
+int32_t tDeserializeSTableIndexRsp(void* buf, int32_t bufLen, STableIndexRsp* pRsp);
+
+
 typedef struct {
   int8_t  mqMsgType;
   int32_t code;
diff --git a/include/common/tmsgdef.h b/include/common/tmsgdef.h
index 8a811774b2..e922df64b3 100644
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@@ -130,6 +130,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_INDEX, "create-index", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_INDEX, "drop-index", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_INDEX, "get-index", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_GET_TABLE_INDEX, "get-table-index", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TOPIC, "create-topic", SMCreateTopicReq, SMCreateTopicRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_TOPIC, "alter-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "drop-topic", NULL, NULL)
@@ -153,6 +154,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_GRANT, "grant", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_AUTH, "auth", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_APPLY_MSG, "mnode-apply", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_BALANCE_VGROUP, "balance-vgroup", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_MERGE_VGROUP, "merge-vgroup", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_REDISTRIBUTE_VGROUP, "redistribute-vgroup", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_VND_MSG)
   TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT, "submit", SSubmitReq, SSubmitRsp)
@@ -169,10 +173,6 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_STB, "vnode-create-stb", SVCreateStbReq, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_ALTER_STB, "vnode-alter-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_STB, "vnode-drop-stb", SVDropStbReq, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONSUME, "vnode-mq-consume", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_MQ_QUERY, "vnode-mq-query", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONNECT, "vnode-mq-connect", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_MQ_DISCONNECT, "vnode-mq-disconnect", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_CHANGE, "vnode-mq-vg-change", SMqRebVgReq, SMqRebVgRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_DELETE, "vnode-mq-vg-delete", SMqVDeleteReq, SMqVDeleteRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_TASK, "vnode-cancel-task", NULL, NULL)
@@ -183,12 +183,8 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_EXPLAIN, "vnode-explain", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_SUBSCRIBE, "vnode-subscribe", SMVSubscribeReq, SMVSubscribeRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_CONSUME, "vnode-consume", SMqPollReq, SMqDataBlkRsp)
-  TD_DEF_MSG_TYPE(TDMT_VND_TASK_DEPLOY, "vnode-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_TASK_RUN, "vnode-stream-task-run", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_TASK_DISPATCH, "vnode-stream-task-dispatch", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_TASK_DISPATCH_WRITE, "vnode-stream-task-dispatch-write", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_TASK_RECOVER, "vnode-stream-task-recover", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_DISPATCH_WRITE, "vnode-stream-task-dispatch-write", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_SMA, "vnode-create-sma", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_SMA, "vnode-cancel-sma", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_SMA, "vnode-drop-sma", NULL, NULL)
@@ -202,11 +198,12 @@ enum {
 
   TD_NEW_MSG_SEG(TDMT_QND_MSG)
 
-  TD_NEW_MSG_SEG(TDMT_SND_MSG)
-  TD_DEF_MSG_TYPE(TDMT_SND_TASK_DEPLOY, "snode-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
-  TD_DEF_MSG_TYPE(TDMT_SND_TASK_RUN, "snode-stream-task-run", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_SND_TASK_DISPATCH, "snode-stream-task-dispatch", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_SND_TASK_RECOVER, "snode-stream-task-recover", NULL, NULL)
+  //shared by snode and vnode
+  TD_NEW_MSG_SEG(TDMT_STREAM_MSG)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_DEPLOY, "stream-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_RUN, "stream-task-run", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_DISPATCH, "stream-task-dispatch", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_RECOVER, "stream-task-recover", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_SCH_MSG)
   TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "link-broken", NULL, NULL)
diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h
index d28f87cb6a..715da5cc99 100644
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@@ -188,10 +188,10 @@
 #define TK_KILL          170
 #define TK_CONNECTION    171
 #define TK_TRANSACTION   172
-#define TK_MERGE         173
+#define TK_BALANCE       173
 #define TK_VGROUP        174
-#define TK_REDISTRIBUTE  175
-#define TK_SPLIT         176
+#define TK_MERGE         175
+#define TK_REDISTRIBUTE  176
 #define TK_SYNCDB        177
 #define TK_DELETE        178
 #define TK_NULL          179
diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h
index ee237741c3..21fee3cc3e 100644
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@@ -272,6 +272,8 @@ int32_t catalogGetDBCfg(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
 
 int32_t catalogGetIndexMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* indexName, SIndexInfo* pInfo);
 
+int32_t catalogGetTableIndex(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const char* tbFName, SArray** pRes);
+
 int32_t catalogGetUdfInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* funcName, SFuncInfo* pInfo);
 
 int32_t catalogChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass);
@@ -280,7 +282,6 @@ int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth);
 
 int32_t catalogUpdateVgEpSet(SCatalog* pCtg, const char* dbFName, int32_t vgId, SEpSet *epSet);
 
-
 int32_t ctgdLaunchAsyncCall(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, uint64_t reqId, bool forceUpdate);
 
 
diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h
index 82924bef3f..c267c89384 100644
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@@ -28,6 +28,14 @@ extern "C" {
 #define DESCRIBE_RESULT_TYPE_LEN  (20 + VARSTR_HEADER_SIZE)
 #define DESCRIBE_RESULT_NOTE_LEN  (8 + VARSTR_HEADER_SIZE)
 
+#define PRIVILEGE_TYPE_MASK(n) (1 << n)
+
+#define PRIVILEGE_TYPE_ALL   PRIVILEGE_TYPE_MASK(0)
+#define PRIVILEGE_TYPE_READ  PRIVILEGE_TYPE_MASK(1)
+#define PRIVILEGE_TYPE_WRITE PRIVILEGE_TYPE_MASK(2)
+
+#define PRIVILEGE_TYPE_TEST_MASK(val, mask) (((val) & (mask)) != 0)
+
 typedef struct SDatabaseOptions {
   ENodeType   type;
   int32_t     buffer;
@@ -316,14 +324,6 @@ typedef struct SDropFunctionStmt {
   bool      ignoreNotExists;
 } SDropFunctionStmt;
 
-#define PRIVILEGE_TYPE_MASK(n) (1 << n)
-
-#define PRIVILEGE_TYPE_ALL   PRIVILEGE_TYPE_MASK(0)
-#define PRIVILEGE_TYPE_READ  PRIVILEGE_TYPE_MASK(1)
-#define PRIVILEGE_TYPE_WRITE PRIVILEGE_TYPE_MASK(2)
-
-#define PRIVILEGE_TYPE_TEST_MASK(val, mask) (((val) & (mask)) != 0)
-
 typedef struct SGrantStmt {
   ENodeType type;
   char      userName[TSDB_USER_LEN];
@@ -333,6 +333,30 @@ typedef struct SGrantStmt {
 
 typedef SGrantStmt SRevokeStmt;
 
+typedef struct SBalanceVgroupStmt {
+  ENodeType type;
+} SBalanceVgroupStmt;
+
+typedef struct SMergeVgroupStmt {
+  ENodeType type;
+  int32_t   vgId1;
+  int32_t   vgId2;
+} SMergeVgroupStmt;
+
+typedef struct SRedistributeVgroupStmt {
+  ENodeType  type;
+  int32_t    vgId;
+  int32_t    dnodeId1;
+  int32_t    dnodeId2;
+  int32_t    dnodeId3;
+  SNodeList* pDnodes;
+} SRedistributeVgroupStmt;
+
+typedef struct SSplitVgroupStmt {
+  ENodeType type;
+  int32_t   vgId;
+} SSplitVgroupStmt;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index e3ed8e1d67..36e9443ff9 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -140,6 +140,7 @@ typedef enum ENodeType {
   QUERY_NODE_DROP_FUNCTION_STMT,
   QUERY_NODE_CREATE_STREAM_STMT,
   QUERY_NODE_DROP_STREAM_STMT,
+  QUERY_NODE_BALANCE_VGROUP_STMT,
   QUERY_NODE_MERGE_VGROUP_STMT,
   QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
   QUERY_NODE_SPLIT_VGROUP_STMT,
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 450eb43280..5a83d1525e 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -653,6 +653,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_VALUE_TOO_LONG            TAOS_DEF_ERROR_CODE(0, 0x2653)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2654)
 #define TSDB_CODE_PAR_INVALID_DELETE_WHERE      TAOS_DEF_ERROR_CODE(0, 0x2655)
+#define TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG   TAOS_DEF_ERROR_CODE(0, 0x2656)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 773e430b83..51c40827b5 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -2394,6 +2394,102 @@ int32_t tDeserializeSUserIndexRsp(void *buf, int32_t bufLen, SUserIndexRsp *pRsp
   return 0;
 }
 
+int32_t tSerializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->tbFName) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSTableIndexReq(void *buf, int32_t bufLen, STableIndexReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->tbFName) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSTableIndexInfo(SEncoder *pEncoder, STableIndexInfo* pInfo) {
+  if (tEncodeI8(pEncoder, pInfo->intervalUnit) < 0) return -1;
+  if (tEncodeI8(pEncoder, pInfo->slidingUnit) < 0) return -1;
+  if (tEncodeI64(pEncoder, pInfo->interval) < 0) return -1;
+  if (tEncodeI64(pEncoder, pInfo->offset) < 0) return -1;
+  if (tEncodeI64(pEncoder, pInfo->sliding) < 0) return -1;
+  if (tEncodeI64(pEncoder, pInfo->dstTbUid) < 0) return -1;
+  if (tEncodeI32(pEncoder, pInfo->dstVgId) < 0) return -1;
+  if (tEncodeCStr(pEncoder, pInfo->expr) < 0) return -1;
+  return 0;
+}
+
+int32_t tSerializeSTableIndexRsp(void *buf, int32_t bufLen, const STableIndexRsp *pRsp) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  int32_t num = taosArrayGetSize(pRsp->pIndex);
+  if (tEncodeI32(&encoder, num) < 0) return -1;
+  if (num > 0) {
+    for (int32_t i = 0; i < num; ++i) {
+      STableIndexInfo* pInfo = (STableIndexInfo*)taosArrayGet(pRsp->pIndex, i);
+      if (tSerializeSTableIndexInfo(&encoder, pInfo) < 0) return -1;
+    }
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSTableIndexInfo(SDecoder *pDecoder, STableIndexInfo *pInfo) {
+  if (tDecodeI8(pDecoder, &pInfo->intervalUnit) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pInfo->slidingUnit) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pInfo->interval) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pInfo->offset) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pInfo->sliding) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pInfo->dstTbUid) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pInfo->dstVgId) < 0) return -1;
+  if (tDecodeCStrAlloc(pDecoder, &pInfo->expr) < 0) return -1;
+
+  return 0;
+}
+
+int32_t tDeserializeSTableIndexRsp(void *buf, int32_t bufLen, STableIndexRsp *pRsp) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  int32_t num = 0;
+  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  if (num > 0) {
+    pRsp->pIndex = taosArrayInit(num, sizeof(STableIndexInfo));
+    if (NULL == pRsp->pIndex) return -1;
+    STableIndexInfo info;
+    for (int32_t i = 0; i < num; ++i) {
+      if (tDeserializeSTableIndexInfo(&decoder, &info) < 0) return -1;
+      if (NULL == taosArrayPush(pRsp->pIndex, &info)) {
+        taosMemoryFree(info.expr);
+        return -1;
+      }
+    }
+  }
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+
 int32_t tSerializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
@@ -3258,6 +3354,89 @@ int32_t tDeserializeSKillTransReq(void *buf, int32_t bufLen, SKillTransReq *pReq
   return 0;
 }
 
+int32_t tSerializeSBalanceVgroupReq(void *buf, int32_t bufLen, SBalanceVgroupReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSBalanceVgroupReq(void *buf, int32_t bufLen, SBalanceVgroupReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSMergeVgroupReq(void *buf, int32_t bufLen, SMergeVgroupReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgId1) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgId2) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSMergeVgroupReq(void *buf, int32_t bufLen, SMergeVgroupReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->vgId1) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->vgId2) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSRedistributeVgroupReq(void *buf, int32_t bufLen, SRedistributeVgroupReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->dnodeId1) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->dnodeId2) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->dnodeId3) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSRedistributeVgroupReq(void *buf, int32_t bufLen, SRedistributeVgroupReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->dnodeId1) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->dnodeId2) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->dnodeId3) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
 int32_t tSerializeSDCreateMnodeReq(void *buf, int32_t bufLen, SDCreateMnodeReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
index 27f5e6f7af..6c2783cb5c 100644
--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@@ -181,6 +181,7 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_SMA, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_STREAM, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_GET_INDEX, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GET_TABLE_INDEX, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
@@ -210,7 +211,7 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DEPLOY_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DEPLOY_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIRM_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
diff --git a/source/dnode/mgmt/mgmt_snode/src/smHandle.c b/source/dnode/mgmt/mgmt_snode/src/smHandle.c
index a3aab439de..66ab627e32 100644
--- a/source/dnode/mgmt/mgmt_snode/src/smHandle.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smHandle.c
@@ -94,9 +94,10 @@ SArray *smGetMsgHandles() {
 
   if (dmSetMgmtHandle(pArray, TDMT_MON_SM_INFO, smPutNodeMsgToMonitorQueue, 0) == NULL) goto _OVER;
 
-  // Requests handled by SNODE
-  if (dmSetMgmtHandle(pArray, TDMT_SND_TASK_DEPLOY, smPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
-  /*if (dmSetMgmtHandle(pArray, TDMT_SND_TASK_EXEC, smPutNodeMsgToExecQueue, 0) == NULL) goto _OVER;*/
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DEPLOY, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RUN, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
 
   code = 0;
 _OVER:
diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index ccc399605b..4c5a32536f 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -210,8 +210,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dDebug("vgId:%d, start to create vnode, tsma:%d standby:%d", createReq.vgId, createReq.isTsma,
-         createReq.standby);
+  dDebug("vgId:%d, start to create vnode, tsma:%d standby:%d", createReq.vgId, createReq.isTsma, createReq.standby);
   vmGenerateVnodeCfg(&createReq, &vnodeCfg);
 
   if (vmTsmaAdjustDays(&vnodeCfg, &createReq) < 0) {
@@ -333,11 +332,6 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_UPDATE_TAG_VAL, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TABLE_META, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TABLES_META, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_CONSUME, vmPutMsgToQueryQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_QUERY, vmPutMsgToQueryQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_CONNECT, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_DISCONNECT, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
-  // if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_SET_CUR, vmPutMsgToWriteQueue, 0)== NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_CANCEL_TASK, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_CREATE_STB, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
@@ -352,13 +346,14 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_CONSUME, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DEPLOY, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_STREAM_TRIGGER, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_RUN, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DISPATCH, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_RECOVER, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_DELETE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_VND_STREAM_TRIGGER, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DEPLOY, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RUN, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
 
   if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
index de7d46ed83..0ad1c508b2 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
@@ -95,6 +95,8 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
         int32_t   vgId = ntohl(pHead->vgId);
         if (vgId == QNODE_HANDLE) {
           pWrapper = &pDnode->wrappers[QNODE];
+        } else if (vgId == SNODE_HANDLE) {
+          pWrapper = &pDnode->wrappers[SNODE];
         } else if (vgId == MNODE_HANDLE) {
           pWrapper = &pDnode->wrappers[MNODE];
         } else {
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index 8ea172ef94..382f8dd55f 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -309,6 +309,7 @@ typedef struct {
   int8_t    slidingUnit;
   int8_t    timezone;
   int32_t   dstVgId;  // for stream
+  int64_t   dstTbUid;
   int64_t   interval;
   int64_t   offset;
   int64_t   sliding;
diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c
index 8497a57edd..3d5dab1894 100644
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@@ -132,7 +132,7 @@ int32_t mndAssignTaskToVg(SMnode* pMnode, STrans* pTrans, SStreamTask* pTask, SS
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
-  mndPersistTaskDeployReq(pTrans, pTask, &plan->execNode.epSet, TDMT_VND_TASK_DEPLOY, pVgroup->vgId);
+  mndPersistTaskDeployReq(pTrans, pTask, &plan->execNode.epSet, TDMT_STREAM_TASK_DEPLOY, pVgroup->vgId);
   return 0;
 }
 
@@ -156,7 +156,7 @@ int32_t mndAssignTaskToSnode(SMnode* pMnode, STrans* pTrans, SStreamTask* pTask,
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
-  mndPersistTaskDeployReq(pTrans, pTask, &plan->execNode.epSet, TDMT_SND_TASK_DEPLOY, 0);
+  mndPersistTaskDeployReq(pTrans, pTask, &plan->execNode.epSet, TDMT_STREAM_TASK_DEPLOY, 0);
   return 0;
 }
 
@@ -222,7 +222,7 @@ int32_t mndAddShuffledSinkToStream(SMnode* pMnode, STrans* pTrans, SStreamObj* p
     // dispatch
     pTask->dispatchType = TASK_DISPATCH__NONE;
 
-    mndPersistTaskDeployReq(pTrans, pTask, &pTask->epSet, TDMT_VND_TASK_DEPLOY, pVgroup->vgId);
+    mndPersistTaskDeployReq(pTrans, pTask, &pTask->epSet, TDMT_STREAM_TASK_DEPLOY, pVgroup->vgId);
   }
   return 0;
 }
@@ -267,8 +267,7 @@ int32_t mndAddFixedSinkToStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStr
   // dispatch
   pTask->dispatchType = TASK_DISPATCH__NONE;
 
-  /*mndPersistTaskDeployReq(pTrans, pTask, &pTask->epSet, TDMT_VND_TASK_DEPLOY, pVgroup->vgId);*/
-  mndPersistTaskDeployReq(pTrans, pTask, &pTask->epSet, TDMT_VND_TASK_DEPLOY, pStream->fixedSinkVg.vgId);
+  mndPersistTaskDeployReq(pTrans, pTask, &pTask->epSet, TDMT_STREAM_TASK_DEPLOY, pStream->fixedSinkVg.vgId);
 
   return 0;
 }
@@ -361,7 +360,7 @@ int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
           ASSERT(taosArrayGetSize(pArray) == 1);
           SStreamTask* lastLevelTask = taosArrayGetP(pArray, 0);
           /*pTask->dispatchMsgType = TDMT_VND_TASK_MERGE_EXEC;*/
-          pTask->dispatchMsgType = TDMT_VND_TASK_DISPATCH;
+          pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
           pTask->dispatchType = TASK_DISPATCH__FIXED;
 
           pTask->fixedEpDispatcher.taskId = lastLevelTask->taskId;
@@ -407,7 +406,7 @@ int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
           pTask->dispatchType = TASK_DISPATCH__SHUFFLE;
 
           /*pTask->dispatchMsgType = TDMT_VND_TASK_WRITE_EXEC;*/
-          pTask->dispatchMsgType = TDMT_VND_TASK_DISPATCH;
+          pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
           SDbObj* pDb = mndAcquireDb(pMnode, pStream->targetDb);
           ASSERT(pDb);
           if (mndExtractDbInfo(pMnode, pDb, &pTask->shuffleDispatcher.dbInfo, NULL) < 0) {
@@ -438,7 +437,7 @@ int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
         } else {
           pTask->dispatchType = TASK_DISPATCH__FIXED;
           /*pTask->dispatchMsgType = TDMT_VND_TASK_WRITE_EXEC;*/
-          pTask->dispatchMsgType = TDMT_VND_TASK_DISPATCH;
+          pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
           SArray* pArray = taosArrayGetP(pStream->tasks, 0);
           // one sink only
           ASSERT(taosArrayGetSize(pArray) == 1);
diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c
index bcc413c1de..1d47f8fc7a 100644
--- a/source/dnode/mnode/impl/src/mndSma.c
+++ b/source/dnode/mnode/impl/src/mndSma.c
@@ -40,6 +40,7 @@ static int32_t  mndSmaGetVgEpSet(SMnode *pMnode, SDbObj *pDb, SVgEpSet **ppVgEpS
 static int32_t  mndProcessMCreateSmaReq(SRpcMsg *pReq);
 static int32_t  mndProcessMDropSmaReq(SRpcMsg *pReq);
 static int32_t  mndProcessGetSmaReq(SRpcMsg *pReq);
+static int32_t mndProcessGetTbSmaReq(SRpcMsg *pReq);
 static int32_t  mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextSma(SMnode *pMnode, void *pIter);
 
@@ -59,6 +60,7 @@ int32_t mndInitSma(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_VND_CREATE_SMA_RSP, mndTransProcessRsp);
   mndSetMsgHandle(pMnode, TDMT_VND_DROP_SMA_RSP, mndTransProcessRsp);
   mndSetMsgHandle(pMnode, TDMT_MND_GET_INDEX, mndProcessGetSmaReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_GET_TABLE_INDEX, mndProcessGetTbSmaReq);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndRetrieveSma);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndCancelGetNextSma);
@@ -870,6 +872,55 @@ static int32_t mndGetSma(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexRsp
   return code;
 }
 
+static int32_t mndGetTableSma(SMnode *pMnode, STableIndexReq *indexReq, STableIndexRsp *rsp, bool *exist) {
+  int32_t  code = 0;
+  SSmaObj *pSma = NULL;
+  SSdb   *pSdb = pMnode->pSdb;
+  void   *pIter = NULL;
+  STableIndexInfo info;
+
+  while (1) {
+    pIter = sdbFetch(pSdb, SDB_SMA, pIter, (void **)&pSma);
+    if (pIter == NULL) break;
+
+    if (pSma->stb[0] != indexReq->tbFName[0] || strcmp(pSma->stb, indexReq->tbFName)) {
+      continue;
+    }
+
+    info.intervalUnit = pSma->intervalUnit;
+    info.slidingUnit = pSma->slidingUnit;
+    info.interval = pSma->interval;
+    info.offset = pSma->offset;
+    info.sliding = pSma->sliding;
+    info.dstTbUid = pSma->dstTbUid;
+    info.dstVgId = pSma->dstVgId;
+    info.expr = taosMemoryMalloc(pSma->exprLen + 1);
+    if (info.expr == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = -1;
+      sdbRelease(pSdb, pSma);
+      return code;
+    }
+
+    memcpy(info.expr, pSma->expr, pSma->exprLen);
+    info.expr[pSma->exprLen] = 0;
+
+    if (NULL == taosArrayPush(rsp->pIndex, &info)) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = -1;
+      taosMemoryFree(info.expr);
+      sdbRelease(pSdb, pSma);
+      return code;
+    }
+
+    *exist = true;
+
+    sdbRelease(pSdb, pSma);
+  }
+  
+  return code;
+}
+
 static int32_t mndProcessGetSmaReq(SRpcMsg *pReq) {
   SUserIndexReq indexReq = {0};
   SMnode       *pMnode = pReq->info.node;
@@ -916,6 +967,59 @@ _OVER:
   return code;
 }
 
+static int32_t mndProcessGetTbSmaReq(SRpcMsg *pReq) {
+  STableIndexReq indexReq = {0};
+  SMnode       *pMnode = pReq->info.node;
+  int32_t       code = -1;
+  STableIndexRsp rsp = {0};
+  bool          exist = false;
+
+  if (tDeserializeSTableIndexReq(pReq->pCont, pReq->contLen, &indexReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto _OVER;
+  }
+
+  rsp.pIndex = taosArrayInit(10, sizeof(STableIndexInfo));
+  if (NULL == rsp.pIndex) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = -1;
+    goto _OVER;
+  }
+
+  code = mndGetTableSma(pMnode, &indexReq, &rsp, &exist);
+  if (code) {
+    goto _OVER;
+  }
+
+  if (!exist) {
+    code = -1;
+    terrno = TSDB_CODE_MND_DB_INDEX_NOT_EXIST;
+  } else {
+    int32_t contLen = tSerializeSTableIndexRsp(NULL, 0, &rsp);
+    void   *pRsp = rpcMallocCont(contLen);
+    if (pRsp == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = -1;
+      goto _OVER;
+    }
+
+    tSerializeSTableIndexRsp(pRsp, contLen, &rsp);
+
+    pReq->info.rsp = pRsp;
+    pReq->info.rspLen = contLen;
+
+    code = 0;
+  }
+
+_OVER:
+  if (code != 0) {
+    mError("failed to get table index %s since %s", indexReq.tbFName, terrstr());
+  }
+
+  return code;
+}
+
+
 static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode  *pMnode = pReq->info.node;
   SSdb    *pSdb = pMnode->pSdb;
diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c
index a0aa2067d3..7abe9e3c0d 100644
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@@ -54,8 +54,8 @@ int32_t mndInitStream(SMnode *pMnode) {
   };
 
   mndSetMsgHandle(pMnode, TDMT_MND_CREATE_STREAM, mndProcessCreateStreamReq);
-  mndSetMsgHandle(pMnode, TDMT_VND_TASK_DEPLOY_RSP, mndTransProcessRsp);
-  mndSetMsgHandle(pMnode, TDMT_SND_TASK_DEPLOY_RSP, mndTransProcessRsp);
+  mndSetMsgHandle(pMnode, TDMT_STREAM_TASK_DEPLOY_RSP, mndTransProcessRsp);
+  /*mndSetMsgHandle(pMnode, TDMT_SND_TASK_DEPLOY_RSP, mndTransProcessRsp);*/
   /*mndSetMsgHandle(pMnode, TDMT_MND_DROP_STREAM, mndProcessDropStreamReq);*/
   /*mndSetMsgHandle(pMnode, TDMT_MND_DROP_STREAM_RSP, mndProcessDropStreamInRsp);*/
 
diff --git a/source/dnode/snode/src/snode.c b/source/dnode/snode/src/snode.c
index 37b406466d..cbbe071c5f 100644
--- a/source/dnode/snode/src/snode.c
+++ b/source/dnode/snode/src/snode.c
@@ -90,7 +90,7 @@ void sndProcessUMsg(SSnode *pSnode, SRpcMsg *pMsg) {
   // stream deploy
   // stream stop/resume
   // operator exec
-  if (pMsg->msgType == TDMT_SND_TASK_DEPLOY) {
+  if (pMsg->msgType == TDMT_STREAM_TASK_DEPLOY) {
     void        *msg = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
     SStreamTask *pTask = taosMemoryMalloc(sizeof(SStreamTask));
     if (pTask == NULL) {
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 4b46e48dd2..7a9c9ef393 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -158,7 +158,7 @@ int32_t vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp
         // TODO: handle error
       }
       break;
-    case TDMT_VND_TASK_DEPLOY: {
+    case TDMT_STREAM_TASK_DEPLOY: {
       if (tqProcessTaskDeploy(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
                               pMsg->contLen - sizeof(SMsgHead)) < 0) {
       }
@@ -238,21 +238,19 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
 
     case TDMT_VND_TABLE_META:
       return vnodeGetTableMeta(pVnode, pMsg);
+
     case TDMT_VND_CONSUME:
       return tqProcessPollReq(pVnode->pTq, pMsg, pInfo->workerId);
 
-    case TDMT_VND_TASK_RUN: {
-      int32_t code = tqProcessTaskRunReq(pVnode->pTq, pMsg);
-      pMsg->pCont = NULL;
-      return code;
-    }
-    case TDMT_VND_TASK_DISPATCH:
+    case TDMT_STREAM_TASK_RUN:
+      return tqProcessTaskRunReq(pVnode->pTq, pMsg);
+    case TDMT_STREAM_TASK_DISPATCH:
       return tqProcessTaskDispatchReq(pVnode->pTq, pMsg);
-    case TDMT_VND_TASK_RECOVER:
+    case TDMT_STREAM_TASK_RECOVER:
       return tqProcessTaskRecoverReq(pVnode->pTq, pMsg);
-    case TDMT_VND_TASK_DISPATCH_RSP:
+    case TDMT_STREAM_TASK_DISPATCH_RSP:
       return tqProcessTaskDispatchRsp(pVnode->pTq, pMsg);
-    case TDMT_VND_TASK_RECOVER_RSP:
+    case TDMT_STREAM_TASK_RECOVER_RSP:
       return tqProcessTaskRecoverRsp(pVnode->pTq, pMsg);
     default:
       vError("unknown msg type:%d in fetch queue", pMsg->msgType);
@@ -262,11 +260,11 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
 
 int32_t vnodeProcessWriteMsg(SVnode *pVnode, int64_t version, SRpcMsg *pMsg, SRpcMsg *pRsp) {
   vTrace("message in write queue is processing");
-  char   *msgstr = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
-  int32_t msgLen = pMsg->contLen - sizeof(SMsgHead);
-  SDeleteRes res = {0};
+  char       *msgstr = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
+  int32_t     msgLen = pMsg->contLen - sizeof(SMsgHead);
+  SDeleteRes  res = {0};
   SReadHandle handle = {.meta = pVnode->pMeta, .config = &pVnode->config, .vnode = pVnode, .pMsgCb = &pVnode->msgCb};
-  
+
   switch (pMsg->msgType) {
     case TDMT_VND_DELETE:
       return qWorkerProcessDeleteMsg(&handle, pVnode->pQuery, pMsg, pRsp, &res);
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 1eec92f47e..260ed1977e 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -310,22 +310,19 @@ typedef struct SCtgCacheOperation {
   int32_t  opId;
   void    *data;
   bool     syncOp;
-  uint64_t seqId;
+  tsem_t   rspSem;  
 } SCtgCacheOperation;
 
 typedef struct SCtgQNode {
-  SCtgCacheOperation     op;
+  SCtgCacheOperation    *op;
   struct SCtgQNode      *next;
 } SCtgQNode;
 
 typedef struct SCtgQueue {
   SRWLatch              qlock;
-  uint64_t              seqId;
-  uint64_t              seqDone;
   SCtgQNode            *head;
   SCtgQNode            *tail;
   tsem_t                reqSem;  
-  tsem_t                rspSem;  
   uint64_t              qRemainNum;
 } SCtgQueue;
 
@@ -493,6 +490,7 @@ int32_t ctgGetDBVgInfoFromMnode(CTG_PARAMS, SBuildUseDBInput *input, SUseDbOutpu
 int32_t ctgGetQnodeListFromMnode(CTG_PARAMS, SArray *out, SCtgTask* pTask);
 int32_t ctgGetDBCfgFromMnode(CTG_PARAMS, const char *dbFName, SDbCfgInfo *out, SCtgTask* pTask);
 int32_t ctgGetIndexInfoFromMnode(CTG_PARAMS, const char *indexName, SIndexInfo *out, SCtgTask* pTask);
+int32_t ctgGetTbIndexFromMnode(CTG_PARAMS, const char *tbFName, SArray** out, SCtgTask* pTask);
 int32_t ctgGetUdfInfoFromMnode(CTG_PARAMS, const char *funcName, SFuncInfo *out, SCtgTask* pTask);
 int32_t ctgGetUserDbAuthFromMnode(CTG_PARAMS, const char *user, SGetUserAuthRsp *out, SCtgTask* pTask);
 int32_t ctgGetTbMetaFromMnodeImpl(CTG_PARAMS, char *dbFName, char* tbName, STableMetaOutput* out, SCtgTask* pTask);
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index 040156eca2..0f6a79c14c 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -506,11 +506,6 @@ int32_t catalogInit(SCatalogCfg *cfg) {
     CTG_ERR_RET(TSDB_CODE_CTG_SYS_ERROR);
   }
   
-  if (tsem_init(&gCtgMgmt.queue.rspSem, 0, 0)) {
-    qError("tsem_init failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
-    CTG_ERR_RET(TSDB_CODE_CTG_SYS_ERROR);
-  }
-
   gCtgMgmt.queue.head = taosMemoryCalloc(1, sizeof(SCtgQNode));
   if (NULL == gCtgMgmt.queue.head) {
     qError("calloc %d failed", (int32_t)sizeof(SCtgQNode));
@@ -1141,6 +1136,17 @@ int32_t catalogGetIndexMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps
   CTG_API_LEAVE(ctgGetIndexInfoFromMnode(CTG_PARAMS_LIST(), indexName, pInfo, NULL));
 }
 
+int32_t catalogGetTableIndex(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const char* tbFName, SArray** pRes) {
+  CTG_API_ENTER();
+  
+  if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == tbFName || NULL == pRes) {
+    CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  CTG_API_LEAVE(ctgGetTbIndexFromMnode(CTG_PARAMS_LIST(), tbFName, pRes, NULL));
+}
+
+
 int32_t catalogGetUdfInfo(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const char* funcName, SFuncInfo* pInfo) {
   CTG_API_ENTER();
   
@@ -1194,10 +1200,6 @@ void catalogDestroy(void) {
   if (tsem_post(&gCtgMgmt.queue.reqSem)) {
     qError("tsem_post failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
   }
-  
-  if (tsem_post(&gCtgMgmt.queue.rspSem)) {
-    qError("tsem_post failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
-  }
 
   while (CTG_IS_LOCKED(&gCtgMgmt.lock)) {
     taosUsleep(1);
diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c
index 8332c7b068..59aab9fd22 100644
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@@ -501,25 +501,6 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-
-void ctgWaitOpDone(SCtgCacheOperation *action) {
-  while (true) {
-    tsem_wait(&gCtgMgmt.queue.rspSem);
-    
-    if (atomic_load_8((int8_t*)&gCtgMgmt.exit)) {
-      tsem_post(&gCtgMgmt.queue.rspSem);
-      break;
-    }
-
-    if (gCtgMgmt.queue.seqDone >= action->seqId) {
-      break;
-    }
-
-    tsem_post(&gCtgMgmt.queue.rspSem);
-    sched_yield();
-  }
-}
-
 void ctgDequeue(SCtgCacheOperation **op) {
   SCtgQNode *orig = gCtgMgmt.queue.head;
   
@@ -530,7 +511,7 @@ void ctgDequeue(SCtgCacheOperation **op) {
   
   taosMemoryFreeClear(orig);
 
-  *op = &node->op;
+  *op = node->op;
 }
 
 
@@ -541,9 +522,11 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
     CTG_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
-  operation->seqId = atomic_add_fetch_64(&gCtgMgmt.queue.seqId, 1);
+  if (operation->syncOp) {
+    tsem_init(&operation->rspSem, 0, 0);
+  }
   
-  node->op = *operation;
+  node->op = operation;
 
   CTG_LOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);
   gCtgMgmt.queue.tail->next = node;
@@ -558,7 +541,8 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
   ctgDebug("action [%s] added into queue", gCtgCacheOperation[operation->opId].name);
 
   if (operation->syncOp) {
-    ctgWaitOpDone(operation);
+    tsem_wait(&operation->rspSem);
+    taosMemoryFree(operation);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -567,7 +551,9 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
 
 int32_t ctgDropDbCacheEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_DROP_DB_CACHE};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_DROP_DB_CACHE;
+  
   SCtgDropDBMsg *msg = taosMemoryMalloc(sizeof(SCtgDropDBMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropDBMsg));
@@ -583,21 +569,24 @@ int32_t ctgDropDbCacheEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId)
   strncpy(msg->dbFName, dbFName, sizeof(msg->dbFName));
   msg->dbId = dbId;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
 
 _return:
 
-  taosMemoryFreeClear(action.data);
+  taosMemoryFreeClear(op->data);
   CTG_RET(code);
 }
 
 int32_t ctgDropDbVgroupEnqueue(SCatalog* pCtg, const char *dbFName, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_DROP_DB_VGROUP, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_DROP_DB_VGROUP;
+  op->syncOp = syncOp;
+  
   SCtgDropDbVgroupMsg *msg = taosMemoryMalloc(sizeof(SCtgDropDbVgroupMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropDbVgroupMsg));
@@ -612,15 +601,15 @@ int32_t ctgDropDbVgroupEnqueue(SCatalog* pCtg, const char *dbFName, bool syncOp)
   msg->pCtg = pCtg;
   strncpy(msg->dbFName, dbFName, sizeof(msg->dbFName));
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
 
 _return:
 
-  taosMemoryFreeClear(action.data);
+  taosMemoryFreeClear(op->data);
   CTG_RET(code);
 }
 
@@ -628,7 +617,10 @@ _return:
 
 int32_t ctgDropStbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_DROP_STB_META, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_DROP_STB_META;
+  op->syncOp = syncOp;
+  
   SCtgDropStbMetaMsg *msg = taosMemoryMalloc(sizeof(SCtgDropStbMetaMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropStbMetaMsg));
@@ -641,15 +633,15 @@ int32_t ctgDropStbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId,
   msg->dbId = dbId;
   msg->suid = suid;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
 
 _return:
 
-  taosMemoryFreeClear(action.data);
+  taosMemoryFreeClear(op->data);
   CTG_RET(code);
 }
 
@@ -657,7 +649,10 @@ _return:
 
 int32_t ctgDropTbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_DROP_TB_META, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_DROP_TB_META;
+  op->syncOp = syncOp;
+  
   SCtgDropTblMetaMsg *msg = taosMemoryMalloc(sizeof(SCtgDropTblMetaMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropTblMetaMsg));
@@ -669,21 +664,24 @@ int32_t ctgDropTbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId,
   strncpy(msg->tbName, tbName, sizeof(msg->tbName));
   msg->dbId = dbId;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
 
 _return:
 
-  taosMemoryFreeClear(action.data);
+  taosMemoryFreeClear(op->data);
   CTG_RET(code);
 }
 
 int32_t ctgUpdateVgroupEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, SDBVgInfo* dbInfo, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_UPDATE_VGROUP, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_UPDATE_VGROUP;
+  op->syncOp = syncOp;
+  
   SCtgUpdateVgMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateVgMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateVgMsg));
@@ -701,22 +699,25 @@ int32_t ctgUpdateVgroupEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId
   msg->dbId = dbId;
   msg->dbInfo = dbInfo;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
 
 _return:
 
   ctgFreeVgInfo(dbInfo);
-  taosMemoryFreeClear(action.data);
+  taosMemoryFreeClear(op->data);
   CTG_RET(code);
 }
 
 int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput *output, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_UPDATE_TB_META, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_UPDATE_TB_META;
+  op->syncOp = syncOp;
+  
   SCtgUpdateTblMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateTblMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateTblMsg));
@@ -731,9 +732,9 @@ int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput *output, bool sy
   msg->pCtg = pCtg;
   msg->output = output;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
   
@@ -746,7 +747,9 @@ _return:
 
 int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char *dbFName, int32_t vgId, SEpSet* pEpSet) {
   int32_t code = 0;
-  SCtgCacheOperation operation= {.opId = CTG_OP_UPDATE_VG_EPSET};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_UPDATE_VG_EPSET;
+  
   SCtgUpdateEpsetMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateEpsetMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateEpsetMsg));
@@ -758,9 +761,9 @@ int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char *dbFName, int32_t vgId, SEp
   msg->vgId = vgId;
   msg->epSet = *pEpSet;
 
-  operation.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &operation));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
 
   return TSDB_CODE_SUCCESS;
   
@@ -775,7 +778,10 @@ _return:
 
 int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncOp) {
   int32_t code = 0;
-  SCtgCacheOperation action= {.opId = CTG_OP_UPDATE_USER, .syncOp = syncOp};
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_UPDATE_USER;
+  op->syncOp = syncOp;
+  
   SCtgUpdateUserMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateUserMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateUserMsg));
@@ -785,9 +791,9 @@ int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncOp
   msg->pCtg = pCtg;
   msg->userAuth = *pAuth;
 
-  action.data = msg;
+  op->data = msg;
 
-  CTG_ERR_JRET(ctgEnqueue(pCtg, &action));
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
   
   return TSDB_CODE_SUCCESS;
   
@@ -1607,6 +1613,39 @@ void ctgUpdateThreadUnexpectedStopped(void) {
   if (CTG_IS_LOCKED(&gCtgMgmt.lock) > 0) CTG_UNLOCK(CTG_READ, &gCtgMgmt.lock);
 }
 
+void ctgCleanupCacheQueue(void) {
+  SCtgQNode *node = NULL;
+  SCtgQNode *nodeNext = NULL;
+
+  while (true) {
+    node = gCtgMgmt.queue.head->next;
+    while (node) {
+      if (node->op) {
+        taosMemoryFree(node->op->data);
+        if (node->op->syncOp) {
+          tsem_post(&node->op->rspSem);
+        } else {
+          taosMemoryFree(node->op);
+        }
+      }
+
+      nodeNext = node->next;
+      taosMemoryFree(node);
+      
+      node = nodeNext;
+    }
+
+    if (CTG_IS_LOCKED(&gCtgMgmt.lock)) {
+      taosUsleep(1);
+    } else {
+      break;
+    }
+  }
+
+  taosMemoryFreeClear(gCtgMgmt.queue.head);
+  gCtgMgmt.queue.tail = NULL;
+}
+
 void* ctgUpdateThreadFunc(void* param) {
   setThreadName("catalog");
 #ifdef WINDOWS
@@ -1622,7 +1661,8 @@ void* ctgUpdateThreadFunc(void* param) {
     }
     
     if (atomic_load_8((int8_t*)&gCtgMgmt.exit)) {
-      tsem_post(&gCtgMgmt.queue.rspSem);
+      CTG_UNLOCK(CTG_READ, &gCtgMgmt.lock);
+      ctgCleanupCacheQueue();
       break;
     }
 
@@ -1634,10 +1674,8 @@ void* ctgUpdateThreadFunc(void* param) {
     
     (*gCtgCacheOperation[operation->opId].func)(operation);
 
-    gCtgMgmt.queue.seqDone = operation->seqId;
-
     if (operation->syncOp) {
-      tsem_post(&gCtgMgmt.queue.rspSem);
+      tsem_post(&operation->rspSem);
     }
 
     CTG_RT_STAT_INC(qDoneNum, 1); 
diff --git a/source/libs/catalog/src/ctgRemote.c b/source/libs/catalog/src/ctgRemote.c
index 188f5b44c0..94c59ddc53 100644
--- a/source/libs/catalog/src/ctgRemote.c
+++ b/source/libs/catalog/src/ctgRemote.c
@@ -85,6 +85,21 @@ int32_t ctgProcessRspMsg(void* out, int32_t reqType, char* msg, int32_t msgSize,
       qDebug("Got index from mnode, indexName:%s", target);
       break;
     }
+    case TDMT_MND_GET_TABLE_INDEX: {
+      if (TSDB_CODE_SUCCESS != rspCode) {
+        qError("error rsp for get table index, error:%s, tbFName:%s", tstrerror(rspCode), target);
+        CTG_ERR_RET(rspCode);
+      }
+      
+      code = queryProcessMsgRsp[TMSG_INDEX(reqType)](out, msg, msgSize);
+      if (code) {
+        qError("Process get table index rsp failed, error:%s, tbFName:%s", tstrerror(code), target);
+        CTG_ERR_RET(code);
+      }
+      
+      qDebug("Got table index from mnode, tbFName:%s", target);
+      break;
+    }
     case TDMT_MND_RETRIEVE_FUNC: {
       if (TSDB_CODE_SUCCESS != rspCode) {
         qError("error rsp for get udf, error:%s, funcName:%s", tstrerror(rspCode), target);
@@ -412,6 +427,44 @@ int32_t ctgGetIndexInfoFromMnode(CTG_PARAMS, const char *indexName, SIndexInfo *
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgGetTbIndexFromMnode(CTG_PARAMS, const char *tbFName, SArray** out, SCtgTask* pTask) {
+  char *msg = NULL;
+  int32_t msgLen = 0;
+  int32_t reqType = TDMT_MND_GET_TABLE_INDEX;
+  void*(*mallocFp)(int32_t) = pTask ? taosMemoryMalloc : rpcMallocCont;
+
+  ctgDebug("try to get tb index from mnode, tbFName:%s", tbFName);
+
+  int32_t code = queryBuildMsg[TMSG_INDEX(reqType)]((void *)tbFName, &msg, 0, &msgLen, mallocFp);
+  if (code) {
+    ctgError("Build get index msg failed, code:%s, tbFName:%s", tstrerror(code), tbFName);
+    CTG_ERR_RET(code);
+  }
+
+  if (pTask) {
+    void* pOut = taosMemoryCalloc(1, POINTER_BYTES);
+    if (NULL == pOut) {
+      CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    CTG_ERR_RET(ctgUpdateMsgCtx(&pTask->msgCtx, reqType, pOut, (char*)tbFName));
+    
+    CTG_RET(ctgAsyncSendMsg(CTG_PARAMS_LIST(), pTask, reqType, msg, msgLen));
+  }
+  
+  SRpcMsg rpcMsg = {
+      .msgType = reqType,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+  rpcSendRecv(pTrans, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+
+  CTG_ERR_RET(ctgProcessRspMsg(out, reqType, rpcRsp.pCont, rpcRsp.contLen, rpcRsp.code, (char*)tbFName));
+  
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t ctgGetUdfInfoFromMnode(CTG_PARAMS, const char *funcName, SFuncInfo *out, SCtgTask* pTask) {
   char *msg = NULL;
   int32_t msgLen = 0;
diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c
index 41ba7a7459..b354470629 100644
--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@@ -449,6 +449,34 @@ static SNode* logicSubplanCopy(const SLogicSubplan* pSrc, SLogicSubplan* pDst) {
   return (SNode*)pDst;
 }
 
+static SNode* physiNodeCopy(const SPhysiNode* pSrc, SPhysiNode* pDst) {
+  CLONE_NODE_FIELD(pOutputDataBlockDesc);
+  CLONE_NODE_FIELD(pConditions);
+  CLONE_NODE_LIST_FIELD(pChildren);
+  return (SNode*)pDst;
+}
+
+static SNode* physiWindowCopy(const SWinodwPhysiNode* pSrc, SWinodwPhysiNode* pDst) {
+  COPY_BASE_OBJECT_FIELD(node, physiNodeCopy);
+  CLONE_NODE_LIST_FIELD(pExprs);
+  CLONE_NODE_LIST_FIELD(pFuncs);
+  CLONE_NODE_FIELD(pTspk);
+  COPY_SCALAR_FIELD(triggerType);
+  COPY_SCALAR_FIELD(watermark);
+  COPY_SCALAR_FIELD(filesFactor);
+  return (SNode*)pDst;
+}
+
+static SNode* physiIntervalCopy(const SIntervalPhysiNode* pSrc, SIntervalPhysiNode* pDst) {
+  COPY_BASE_OBJECT_FIELD(window, physiWindowCopy);
+  COPY_SCALAR_FIELD(interval);
+  COPY_SCALAR_FIELD(offset);
+  COPY_SCALAR_FIELD(sliding);
+  COPY_SCALAR_FIELD(intervalUnit);
+  COPY_SCALAR_FIELD(slidingUnit);
+  return (SNode*)pDst;
+}
+
 static SNode* dataBlockDescCopy(const SDataBlockDescNode* pSrc, SDataBlockDescNode* pDst) {
   COPY_SCALAR_FIELD(dataBlockId);
   CLONE_NODE_LIST_FIELD(pSlots);
@@ -575,6 +603,12 @@ SNodeptr nodesCloneNode(const SNodeptr pNode) {
       return logicIndefRowsFuncCopy((const SIndefRowsFuncLogicNode*)pNode, (SIndefRowsFuncLogicNode*)pDst);
     case QUERY_NODE_LOGIC_SUBPLAN:
       return logicSubplanCopy((const SLogicSubplan*)pNode, (SLogicSubplan*)pDst);
+    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+      return physiIntervalCopy((const SIntervalPhysiNode*)pNode, (SIntervalPhysiNode*)pDst);
     default:
       break;
   }
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index d8914fc7e6..a753871834 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -164,9 +164,14 @@ SNodeptr nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SCreateStreamStmt));
     case QUERY_NODE_DROP_STREAM_STMT:
       return makeNode(type, sizeof(SDropStreamStmt));
+    case QUERY_NODE_BALANCE_VGROUP_STMT:
+      return makeNode(type, sizeof(SBalanceVgroupStmt));
     case QUERY_NODE_MERGE_VGROUP_STMT:
+      return makeNode(type, sizeof(SMergeVgroupStmt));
     case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
+      return makeNode(type, sizeof(SRedistributeVgroupStmt));
     case QUERY_NODE_SPLIT_VGROUP_STMT:
+      return makeNode(type, sizeof(SSplitVgroupStmt));
     case QUERY_NODE_SYNCDB_STMT:
       break;
     case QUERY_NODE_GRANT_STMT:
diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h
index ca7fa7a4c6..0c6663d29a 100644
--- a/source/libs/parser/inc/parAst.h
+++ b/source/libs/parser/inc/parAst.h
@@ -187,6 +187,7 @@ SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const
                               SNode* pOptions, SNode* pQuery);
 SNode* createDropStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pStreamName);
 SNode* createKillStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pId);
+SNode* createBalanceVgroupStmt(SAstCreateContext* pCxt);
 SNode* createMergeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId1, const SToken* pVgId2);
 SNode* createRedistributeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId, SNodeList* pDnodes);
 SNode* createSplitVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId);
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index d63ce74fa7..bf23ff08b2 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -469,9 +469,10 @@ cmd ::= KILL QUERY NK_INTEGER(A).
 cmd ::= KILL TRANSACTION NK_INTEGER(A).                                           { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &A); }
 
 /************************************************ merge/redistribute/ vgroup ******************************************/
+cmd ::= BALANCE VGROUP.                                                           { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); }
 cmd ::= MERGE VGROUP NK_INTEGER(A) NK_INTEGER(B).                                 { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &A, &B); }
 cmd ::= REDISTRIBUTE VGROUP NK_INTEGER(A) dnode_list(B).                          { pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &A, B); }
-cmd ::= SPLIT VGROUP NK_INTEGER(A).                                               { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &A); }
+//cmd ::= SPLIT VGROUP NK_INTEGER(A).                                               { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &A); }
 
 %type dnode_list                                                                  { SNodeList* }
 %destructor dnode_list                                                            { nodesDestroyList($$); }
diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c
index 24db0671ac..613a2d867d 100644
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -1435,25 +1435,37 @@ SNode* createKillStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pId
   return (SNode*)pStmt;
 }
 
+SNode* createBalanceVgroupStmt(SAstCreateContext* pCxt) {
+  CHECK_PARSER_STATUS(pCxt);
+  SBalanceVgroupStmt* pStmt = nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_STMT);
+  CHECK_OUT_OF_MEM(pStmt);
+  return (SNode*)pStmt;
+}
+
 SNode* createMergeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId1, const SToken* pVgId2) {
   CHECK_PARSER_STATUS(pCxt);
-  SNode* pStmt = nodesMakeNode(QUERY_NODE_MERGE_VGROUP_STMT);
+  SMergeVgroupStmt* pStmt = nodesMakeNode(QUERY_NODE_MERGE_VGROUP_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  pStmt->vgId1 = taosStr2Int32(pVgId1->z, NULL, 10);
+  pStmt->vgId2 = taosStr2Int32(pVgId2->z, NULL, 10);
+  return (SNode*)pStmt;
 }
 
 SNode* createRedistributeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId, SNodeList* pDnodes) {
   CHECK_PARSER_STATUS(pCxt);
-  SNode* pStmt = nodesMakeNode(QUERY_NODE_REDISTRIBUTE_VGROUP_STMT);
+  SRedistributeVgroupStmt* pStmt = nodesMakeNode(QUERY_NODE_REDISTRIBUTE_VGROUP_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  pStmt->vgId = taosStr2Int32(pVgId->z, NULL, 10);
+  pStmt->pDnodes = pDnodes;
+  return (SNode*)pStmt;
 }
 
 SNode* createSplitVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId) {
   CHECK_PARSER_STATUS(pCxt);
-  SNode* pStmt = nodesMakeNode(QUERY_NODE_SPLIT_VGROUP_STMT);
+  SSplitVgroupStmt* pStmt = nodesMakeNode(QUERY_NODE_SPLIT_VGROUP_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  pStmt->vgId = taosStr2Int32(pVgId->z, NULL, 10);
+  return (SNode*)pStmt;
 }
 
 SNode* createSyncdbStmt(SAstCreateContext* pCxt, const SToken* pDbName) {
diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c
index d13f17f895..284a3a620b 100644
--- a/source/libs/parser/src/parTokenizer.c
+++ b/source/libs/parser/src/parTokenizer.c
@@ -41,6 +41,7 @@ static SKeyword keywordTable[] = {
     {"AS",            TK_AS},
     {"ASC",           TK_ASC},
     {"AT_ONCE",       TK_AT_ONCE},
+    {"BALANCE",       TK_BALANCE},
     {"BETWEEN",       TK_BETWEEN},
     {"BINARY",        TK_BINARY},
     {"BIGINT",        TK_BIGINT},
@@ -116,6 +117,7 @@ static SKeyword keywordTable[] = {
     {"LOCAL",         TK_LOCAL},
     {"MATCH",         TK_MATCH},
     {"MAXROWS",       TK_MAXROWS},
+    {"MERGE",         TK_MERGE},
     {"MINROWS",       TK_MINROWS},
     {"MINUS",         TK_MINUS},
     {"MNODE",         TK_MNODE},
@@ -151,6 +153,7 @@ static SKeyword keywordTable[] = {
     {"QUERY",         TK_QUERY},
     {"RATIO",         TK_RATIO},
     {"READ",          TK_READ},
+    {"REDISTRIBUTE",  TK_REDISTRIBUTE},
     {"RENAME",        TK_RENAME},
     {"REPLICA",       TK_REPLICA},
     {"RESET",         TK_RESET},
@@ -171,6 +174,7 @@ static SKeyword keywordTable[] = {
     {"SNODE",         TK_SNODE},
     {"SNODES",        TK_SNODES},
     {"SOFFSET",       TK_SOFFSET},
+    // {"SPLIT",         TK_SPLIT},
     {"STABLE",        TK_STABLE},
     {"STABLES",       TK_STABLES},
     {"STATE",         TK_STATE},
@@ -208,6 +212,7 @@ static SKeyword keywordTable[] = {
     {"VARCHAR",       TK_VARCHAR},
     {"VARIABLES",     TK_VARIABLES},
     {"VERBOSE",       TK_VERBOSE},
+    {"VGROUP",        TK_VGROUP},
     {"VGROUPS",       TK_VGROUPS},
     {"VNODES",        TK_VNODES},
     {"WAL",           TK_WAL},
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index d81c6760e8..f77bbb34f3 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -847,9 +847,9 @@ static EDealRes translateJsonOperator(STranslateContext* pCxt, SOperatorNode* pO
   if (TSDB_DATA_TYPE_JSON != ldt.type || TSDB_DATA_TYPE_BINARY != rdt.type) {
     return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_WRONG_VALUE_TYPE, ((SExprNode*)(pOp->pRight))->aliasName);
   }
-  if(pOp->opType == OP_TYPE_JSON_GET_VALUE){
+  if (pOp->opType == OP_TYPE_JSON_GET_VALUE) {
     pOp->node.resType.type = TSDB_DATA_TYPE_JSON;
-  }else if(pOp->opType == OP_TYPE_JSON_CONTAINS){
+  } else if (pOp->opType == OP_TYPE_JSON_CONTAINS) {
     pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
   }
   pOp->node.resType.bytes = tDataTypes[pOp->node.resType.type].bytes;
@@ -3611,6 +3611,55 @@ static int32_t translateRevoke(STranslateContext* pCxt, SRevokeStmt* pStmt) {
   return buildCmdMsg(pCxt, TDMT_MND_ALTER_USER, (FSerializeFunc)tSerializeSAlterUserReq, &req);
 }
 
+static int32_t translateBalanceVgroup(STranslateContext* pCxt, SBalanceVgroupStmt* pStmt) {
+  SBalanceVgroupReq req = {0};
+  return buildCmdMsg(pCxt, TDMT_MND_BALANCE_VGROUP, (FSerializeFunc)tSerializeSBalanceVgroupReq, &req);
+}
+
+static int32_t translateMergeVgroup(STranslateContext* pCxt, SMergeVgroupStmt* pStmt) {
+  SMergeVgroupReq req = {.vgId1 = pStmt->vgId1, .vgId2 = pStmt->vgId2};
+  return buildCmdMsg(pCxt, TDMT_MND_MERGE_VGROUP, (FSerializeFunc)tSerializeSMergeVgroupReq, &req);
+}
+
+static int32_t checkDnodeIds(STranslateContext* pCxt, SRedistributeVgroupStmt* pStmt) {
+  int32_t numOfDnodes = LIST_LENGTH(pStmt->pDnodes);
+  if (numOfDnodes > 3 || numOfDnodes < 1) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG);
+  }
+
+  SNode* pNode = NULL;
+  FOREACH(pNode, pStmt->pDnodes) {
+    SValueNode* pVal = (SValueNode*)pNode;
+    if (DEAL_RES_ERROR == translateValue(pCxt, pVal)) {
+      return pCxt->errCode;
+    }
+  }
+
+  pStmt->dnodeId1 = getBigintFromValueNode((SValueNode*)nodesListGetNode(pStmt->pDnodes, 0));
+  pStmt->dnodeId2 = -1;
+  pStmt->dnodeId3 = -1;
+  if (numOfDnodes > 1) {
+    pStmt->dnodeId2 = getBigintFromValueNode((SValueNode*)nodesListGetNode(pStmt->pDnodes, 1));
+  }
+  if (numOfDnodes > 2) {
+    pStmt->dnodeId3 = getBigintFromValueNode((SValueNode*)nodesListGetNode(pStmt->pDnodes, 2));
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateRedistributeVgroup(STranslateContext* pCxt, SRedistributeVgroupStmt* pStmt) {
+  SRedistributeVgroupReq req = {.vgId = pStmt->vgId};
+  int32_t                code = checkDnodeIds(pCxt, pStmt);
+  if (TSDB_CODE_SUCCESS == code) {
+    req.dnodeId1 = pStmt->dnodeId1;
+    req.dnodeId2 = pStmt->dnodeId2;
+    req.dnodeId3 = pStmt->dnodeId3;
+    code = buildCmdMsg(pCxt, TDMT_MND_REDISTRIBUTE_VGROUP, (FSerializeFunc)tSerializeSRedistributeVgroupReq, &req);
+  }
+  return code;
+}
+
 static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pNode)) {
@@ -3733,6 +3782,15 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_REVOKE_STMT:
       code = translateRevoke(pCxt, (SRevokeStmt*)pNode);
       break;
+    case QUERY_NODE_BALANCE_VGROUP_STMT:
+      code = translateBalanceVgroup(pCxt, (SBalanceVgroupStmt*)pNode);
+      break;
+    case QUERY_NODE_MERGE_VGROUP_STMT:
+      code = translateMergeVgroup(pCxt, (SMergeVgroupStmt*)pNode);
+      break;
+    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
+      code = translateRedistributeVgroup(pCxt, (SRedistributeVgroupStmt*)pNode);
+      break;
     default:
       break;
   }
diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c
index f30cc1111f..147ff933fb 100644
--- a/source/libs/parser/src/parUtil.c
+++ b/source/libs/parser/src/parUtil.c
@@ -180,6 +180,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Value too long for column/tag: %s";
     case TSDB_CODE_PAR_INVALID_DELETE_WHERE:
       return "The DELETE statement must have a definite time window range";
+    case TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG:
+      return "The REDISTRIBUTE VGROUP statement only support 1 to 3 dnodes";
     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 ed837ae20f..1626c05454 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -138,17 +138,17 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYFALLBACK 1
-#define YYNSTATE             616
+#define YYNSTATE             615
 #define YYNRULE              452
 #define YYNTOKEN             238
-#define YY_MAX_SHIFT         615
-#define YY_MIN_SHIFTREDUCE   902
-#define YY_MAX_SHIFTREDUCE   1353
-#define YY_ERROR_ACTION      1354
-#define YY_ACCEPT_ACTION     1355
-#define YY_NO_ACTION         1356
-#define YY_MIN_REDUCE        1357
-#define YY_MAX_REDUCE        1808
+#define YY_MAX_SHIFT         614
+#define YY_MIN_SHIFTREDUCE   901
+#define YY_MAX_SHIFTREDUCE   1352
+#define YY_ERROR_ACTION      1353
+#define YY_ACCEPT_ACTION     1354
+#define YY_NO_ACTION         1355
+#define YY_MIN_REDUCE        1356
+#define YY_MAX_REDUCE        1807
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -217,223 +217,223 @@ typedef union {
 *********** Begin parsing tables **********************************************/
 #define YY_ACTTAB_COUNT (2165)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */    72,  355, 1655, 1642,   28,  230,  296, 1465, 1642,  608,
- /*    10 */   607,  313,   35,   33,  530,   36,   34,   32,   31,   30,
- /*    20 */   305, 1481, 1167, 1639,  530,  490,  106, 1477, 1639,  389,
- /*    30 */  1671,  390, 1389,  428,  490,  277,  152,  349,  514, 1635,
- /*    40 */  1641,  529,  133, 1488, 1635, 1641, 1445, 1165,  513,  132,
- /*    50 */   533, 1369, 1625, 1488,  114,  533,  529,  494,   14,  530,
- /*    60 */    35,   33, 1294,  114, 1173, 1416,  932,   63,  305, 1684,
- /*    70 */  1167,  353,   82, 1656,  516, 1658, 1659,  512, 1786,  533,
- /*    80 */   110,    1, 1724,   56, 1532, 1308,  278, 1720, 1488, 1483,
- /*    90 */   147,  295,  112,  517, 1783, 1165, 1530,  529, 1786, 1578,
- /*   100 */   564,  112,   39,  612,  936,  937,   14,  145, 1731, 1732,
- /*   110 */   149, 1736, 1173, 1166, 1783,  492,  144, 1731, 1732,  563,
- /*   120 */  1736,  562,  561,  560,  407,  588,  587,  586,  320,    2,
- /*   130 */   585,  584,  583,  116,  578,  577,  576,  575,  574,  573,
- /*   140 */   572,  571,  123,  567, 1358,   36,   34,   32,   31,   30,
- /*   150 */   397,  612,  390, 1389,  142,  317, 1168, 1191,   38, 1671,
- /*   160 */    55, 1166, 1568, 1570, 1466,   96, 1526,  483,   95,   94,
- /*   170 */    93,   92,   91,   90,   89,   88,   87,  479,  388, 1171,
- /*   180 */  1172,  392, 1218, 1219, 1221, 1222, 1223, 1224, 1225,  509,
- /*   190 */   531, 1233, 1234, 1235, 1236, 1237, 1238,   36,   34,   32,
- /*   200 */    31,   30,  517,  482, 1168,  308,  581,   96, 1577,  150,
+ /*     0 */    72,  354, 1654, 1641,   28,  230,  296, 1464, 1641,  607,
+ /*    10 */   606,  313,   35,   33,  529,   36,   34,   32,   31,   30,
+ /*    20 */   305, 1480, 1166, 1638,  529,  489,  106, 1476, 1638,  388,
+ /*    30 */  1670,  389, 1388,  427,  489,  277,  152,  348,  513, 1634,
+ /*    40 */  1640,  528,  133, 1487, 1634, 1640, 1444, 1164,  512,  132,
+ /*    50 */   532, 1368, 1624, 1487,  114,  532,  528,  493,   14,  529,
+ /*    60 */    35,   33, 1293,  114, 1172, 1415,  931,   63,  305, 1683,
+ /*    70 */  1166,  352,   82, 1655,  515, 1657, 1658,  511, 1785,  532,
+ /*    80 */   110,    1, 1723,   56, 1531, 1307,  278, 1719, 1487, 1482,
+ /*    90 */   147,  295,  112,  516, 1782, 1164, 1529,  528, 1785, 1577,
+ /*   100 */   563,  112,   39,  611,  935,  936,   14,  145, 1730, 1731,
+ /*   110 */   149, 1735, 1172, 1165, 1782,  491,  144, 1730, 1731,  562,
+ /*   120 */  1735,  561,  560,  559,  406,  587,  586,  585,  320,    2,
+ /*   130 */   584,  583,  582,  116,  577,  576,  575,  574,  573,  572,
+ /*   140 */   571,  570,  123,  566, 1357,   36,   34,   32,   31,   30,
+ /*   150 */   396,  611,  389, 1388,  142,  317, 1167, 1190,   38, 1670,
+ /*   160 */    55, 1165, 1567, 1569, 1465,   96, 1525,  482,   95,   94,
+ /*   170 */    93,   92,   91,   90,   89,   88,   87,  478,  387, 1170,
+ /*   180 */  1171,  391, 1217, 1218, 1220, 1221, 1222, 1223, 1224,  508,
+ /*   190 */   530, 1232, 1233, 1234, 1235, 1236, 1237,   36,   34,   32,
+ /*   200 */    31,   30,  516,  481, 1167,  308,  580,   96, 1576,  150,
  /*   210 */    95,   94,   93,   92,   91,   90,   89,   88,   87,  288,
- /*   220 */   130,  407,   36,   34,   32,   31,   30, 1171, 1172, 1491,
- /*   230 */  1218, 1219, 1221, 1222, 1223, 1224, 1225,  509,  531, 1233,
- /*   240 */  1234, 1235, 1236, 1237, 1238,   35,   33,  343,  485,  480,
- /*   250 */  1355,  442,  441,  305, 1655, 1167,  440,  200,  252,  111,
- /*   260 */   437, 1518,  379,  436,  435,  434,   35,   33,  289,  447,
- /*   270 */   287,  286, 1001,  430,  305, 1479, 1167,  432,  129,  309,
- /*   280 */  1165,   79, 1671,   55,  455,   66,  150,  130,  150, 1003,
- /*   290 */   514,   14, 1205,  484,  115, 1639, 1490, 1173,  193,  431,
- /*   300 */   513, 1165, 1480,  949, 1625,  948,  161,  160,  321,  494,
- /*   310 */   450, 1635, 1641,  394,    2,  444, 1192, 1643, 1173, 1189,
- /*   320 */   192, 1684,  533,  490,   82, 1656,  516, 1658, 1659,  512,
- /*   330 */    24,  533,  950, 1350, 1724,    8,  612, 1639,  278, 1720,
- /*   340 */    36,   34,   32,   31,   30,   51, 1166, 1464,   50, 1786,
- /*   350 */  1786,  566,  114, 1635, 1641,   65,  294,  612, 1380,  194,
- /*   360 */   559,  147,  147, 1463,  533, 1783, 1783, 1166, 1357, 1039,
- /*   370 */   556,  555,  554, 1043,  553, 1045, 1046,  552, 1048,  549,
- /*   380 */  1379, 1054,  546, 1056, 1057,  543,  540,    7,   55, 1168,
- /*   390 */   112, 1190,  105,  104,  103,  102,  101,  100,   99,   98,
- /*   400 */    97,   32,   31,   30,  566,  146, 1731, 1732, 1625, 1736,
- /*   410 */  1168,  150, 1171, 1172, 1349, 1218, 1219, 1221, 1222, 1223,
- /*   420 */  1224, 1225,  509,  531, 1233, 1234, 1235, 1236, 1237, 1238,
- /*   430 */  1625,  569,  157, 1171, 1172,  463, 1218, 1219, 1221, 1222,
- /*   440 */  1223, 1224, 1225,  509,  531, 1233, 1234, 1235, 1236, 1237,
- /*   450 */  1238,   35,   33, 1239,   26, 1378,  564,   61,  466,  305,
- /*   460 */    60, 1167,  564,  150,   36,   34,   32,   31,   30,   63,
- /*   470 */  1406,  396,   35,   33,  392,  563, 1655,  562,  561,  560,
- /*   480 */   305,  563, 1167,  562,  561,  560, 1165, 1193,  530, 1318,
- /*   490 */   530, 1484,  443,   36,   34,   32,   31,   30, 1786, 1786,
- /*   500 */   354, 1645,  106, 1173, 1671, 1625, 1473, 1165,   55,  433,
- /*   510 */  1785,  147,  493,  456, 1783, 1783,  150, 1488, 1377, 1488,
- /*   520 */     9,  570,  513, 1460, 1173, 1419, 1625,  454,  476, 1316,
- /*   530 */  1317, 1319, 1320,   36,   34,   32,   31,   30, 1647,  279,
- /*   540 */   452,    9,  612, 1684,  439,  438,   83, 1656,  516, 1658,
- /*   550 */  1659,  512, 1166,  533, 1786, 1475, 1724, 1532, 1289,  315,
- /*   560 */   298, 1720,  143,  612,  310, 1786,  147,  130, 1625, 1530,
- /*   570 */  1783, 1256, 1301, 1166,  222, 1786, 1490,  148, 1191,  472,
- /*   580 */  1751, 1783,  348, 1738,  347,  442,  441, 1784,  530,  340,
- /*   590 */   440, 1783, 1532,  111,  437, 1168, 1532,  436,  435,  434,
- /*   600 */   364,  582,  580,  316, 1531, 1569, 1570, 1735, 1530,  342,
- /*   610 */   338, 1293,  221, 1376,  936,  937, 1168, 1488, 1171, 1172,
- /*   620 */  1257, 1218, 1219, 1221, 1222, 1223, 1224, 1225,  509,  531,
- /*   630 */  1233, 1234, 1235, 1236, 1237, 1238,  150,   11,   10, 1171,
- /*   640 */  1172, 1262, 1218, 1219, 1221, 1222, 1223, 1224, 1225,  509,
- /*   650 */   531, 1233, 1234, 1235, 1236, 1237, 1238,   35,   33,  276,
- /*   660 */  1655, 1189,  530, 1625,  530,  305, 1375, 1167,  372,   54,
- /*   670 */  1374,  384, 1373, 1471,  365,  197,  406,  508,   27,  303,
- /*   680 */  1251, 1252, 1253, 1254, 1255, 1259, 1260, 1261, 1671,  385,
- /*   690 */   530, 1488, 1165, 1488, 1244,  530,  514, 1372, 1565,  530,
- /*   700 */  1191,  432, 1485, 1371,  318,  159,  513, 1604, 1191, 1173,
- /*   710 */  1625,  464,  130,  530, 1151, 1152, 1625, 1194, 1270, 1488,
- /*   720 */  1625, 1490, 1625,  431, 1488,  527,    2, 1684, 1488, 1258,
- /*   730 */    83, 1656,  516, 1658, 1659,  512,  948,  533, 1368, 1367,
- /*   740 */  1724, 1220, 1488,  498,  298, 1720, 1799, 1625,  612,  120,
- /*   750 */  1263, 1743, 1289, 1625, 1366, 1758, 1365, 1364, 1166,  383,
- /*   760 */  1363,  426,  378,  377,  376,  375,  374,  371,  370,  369,
- /*   770 */   368,  367,  363,  362,  361,  360,  359,  358,  357,  356,
- /*   780 */   530,  131,  530,  530, 1738, 1370,  258,   25, 1625, 1625,
- /*   790 */   468, 1738,  528, 1362,  243,  319, 1361,  501,  256,   53,
- /*   800 */  1613, 1168,   52, 1360, 1625,  506, 1625, 1625, 1734, 1488,
- /*   810 */  1625, 1488, 1488,  185, 1446, 1733,  183, 1292,  187,  162,
- /*   820 */   189,  186, 1176,  188, 1171, 1172,   46, 1218, 1219, 1221,
- /*   830 */  1222, 1223, 1224, 1225,  509,  531, 1233, 1234, 1235, 1236,
- /*   840 */  1237, 1238,  206, 1625,   55,  330, 1625,   36,   34,   32,
- /*   850 */    31,   30,  191, 1625, 1401,  190, 1167, 1399,  209,   11,
- /*   860 */    10, 1352, 1353, 1220,   46,   37,   37, 1315,   37,  232,
- /*   870 */   558, 1220,  457,  118,  119,   78,  445,  120, 1175,  448,
- /*   880 */    81, 1165,  538,  225,  973,   74,  119,  477, 1179,  120,
- /*   890 */   496,  216, 1672,  279,  121, 1390, 1655, 1527, 1173,  211,
- /*   900 */   425,  974,  119, 1754,  491,  251, 1264, 1226,  322, 1124,
- /*   910 */   234,   59,   58,  352,  522,  240,  156, 1205, 1032, 1189,
- /*   920 */   224,  346,    3, 1060, 1671, 1256, 1248, 1064,  499,  227,
- /*   930 */  1070,  229,  493,  275,    5, 1068,  336,  612,  332,  328,
- /*   940 */   153,  323,  513,  122, 1178,  329, 1625, 1166,  325,  284,
- /*   950 */  1001,  285,  312,  311,  248, 1135,  158,  366, 1567,  373,
- /*   960 */   381,  380, 1181, 1684,  382,  386,   83, 1656,  516, 1658,
- /*   970 */  1659,  512,  150,  533, 1257, 1655, 1724, 1195, 1198,  387,
- /*   980 */   298, 1720,  143,  395,  502,  398,  399, 1174, 1197,  400,
- /*   990 */  1168,  165,  167, 1199,  170, 1262,  172,  404,  401,  403,
- /*  1000 */  1752, 1196,  175, 1671, 1173,   62,  405,  408,  178,  427,
- /*  1010 */  1173,  514,   86, 1171, 1172,  429,  293, 1478, 1608,  182,
- /*  1020 */  1474,  513,  184,  124,  249, 1625,  125, 1476, 1655, 1472,
- /*  1030 */   126,  127,   27,  303, 1251, 1252, 1253, 1254, 1255, 1259,
- /*  1040 */  1260, 1261, 1684,  534,  195,   83, 1656,  516, 1658, 1659,
- /*  1050 */   512,  458,  533, 1177,  198, 1724, 1671,  462,  465,  298,
- /*  1060 */  1720, 1799,  201,  467,  514,  469,  459,  470,  478,  204,
- /*  1070 */  1781, 1194, 1765,  207,  513,  520, 1764,  475, 1625, 1655,
- /*  1080 */   297, 1755,  210,  481,  215,    6,  487, 1745,  474,  217,
- /*  1090 */  1655, 1289,  113, 1193,   40, 1684, 1182,  503,   83, 1656,
- /*  1100 */   516, 1658, 1659,  512, 1739,  533,  218, 1671, 1724,  137,
- /*  1110 */   500,  299,  298, 1720, 1799,  514,   18,  518, 1671, 1185,
- /*  1120 */   519, 1705, 1576, 1742, 1782,  513,  514,  223,  226, 1625,
- /*  1130 */   531, 1233, 1234,  228,  494, 1575,  513, 1802, 1655,  523,
- /*  1140 */  1625,  307,  236,  497,  524,  494, 1684,  238,  504,  263,
- /*  1150 */  1656,  516, 1658, 1659,  512,  525,  533, 1684,  250,   71,
- /*  1160 */   263, 1656,  516, 1658, 1659,  512, 1671,  533, 1489,   73,
- /*  1170 */  1461,  536,  253,  245,  514, 1786,  611,   47, 1655,  255,
- /*  1180 */   136,  264,  274,  265,  513, 1619, 1786,  149, 1625,  257,
- /*  1190 */  1618, 1783,   57, 1617,  324, 1614,  326,  327,  147,  331,
- /*  1200 */  1160, 1161, 1783,  154, 1612, 1684, 1671,  333,   84, 1656,
- /*  1210 */   516, 1658, 1659,  512,  514,  533,  334,  335, 1724, 1611,
- /*  1220 */   180,  337, 1723, 1720,  513, 1610,  339, 1609, 1625,  341,
- /*  1230 */  1594,  155,  141, 1138,  344,  345, 1137, 1655,  424,  420,
- /*  1240 */   416,  412,  179, 1588, 1587, 1684,  350,  351,   84, 1656,
- /*  1250 */   516, 1658, 1659,  512, 1586,  533, 1585, 1107, 1724, 1109,
- /*  1260 */   117, 1542,  505, 1720, 1560, 1671, 1559,   64, 1558, 1557,
- /*  1270 */   177, 1556, 1555,  511, 1554, 1553, 1552, 1551, 1550, 1549,
- /*  1280 */  1548, 1547, 1546,  513, 1545, 1544, 1543, 1625, 1541, 1655,
- /*  1290 */  1540, 1539, 1538, 1537, 1536, 1535, 1534, 1533, 1655, 1418,
- /*  1300 */  1386,  140,  163,  939, 1684, 1385, 1602,  272, 1656,  516,
- /*  1310 */  1658, 1659,  512,  510,  533,  507, 1696, 1671,  938, 1596,
- /*  1320 */   108, 1584,  171, 1583,  109,  514, 1671,  176, 1573,  168,
- /*  1330 */  1467,  173,  967,  402,  514,  513, 1417, 1415, 1413, 1625,
- /*  1340 */   164, 1411,  391, 1409,  513,  393,  169,  174, 1625,  411,
- /*  1350 */   409,  166,  410,  415, 1655,  413, 1684, 1398,  414,  134,
- /*  1360 */  1656,  516, 1658, 1659,  512, 1684,  533,  417,   84, 1656,
- /*  1370 */   516, 1658, 1659,  512,  418,  533,  419,  422, 1724,  615,
- /*  1380 */   421,  423, 1671, 1721, 1397, 1384, 1469, 1074, 1073, 1468,
- /*  1390 */   514,  579, 1000,  247,  999,  998,  997,  581,  994,  993,
- /*  1400 */   513,  992,  495, 1800, 1625,  107,  181,  473, 1655, 1407,
- /*  1410 */   290,  604,  600,  596,  592,  246,   45, 1655, 1402,  291,
- /*  1420 */   446, 1684, 1400,  292,  273, 1656,  516, 1658, 1659,  512,
- /*  1430 */   449,  533, 1383,  451, 1382,  453, 1671,   85, 1601, 1145,
- /*  1440 */    80, 1595,  460,  241,  514, 1671, 1582, 1581, 1580, 1572,
- /*  1450 */    67,  203,   15,  514,  513,  208,    4,   37, 1625,   49,
- /*  1460 */   461,  135,   48,  513,  199,   43,  213, 1625,   16, 1314,
- /*  1470 */  1655,  205,  212,  214,   22, 1684,  526, 1307,  268, 1656,
- /*  1480 */   516, 1658, 1659,  512, 1684,  533,  128,  134, 1656,  516,
- /*  1490 */  1658, 1659,  512,   68,  533, 1645,   23,  220, 1671,   42,
- /*  1500 */  1655,  471,   17, 1286,  202, 1285,  514,  138, 1343, 1338,
- /*  1510 */  1332, 1337,  300, 1342, 1341,  486,  513,  301,   10,   19,
- /*  1520 */  1625, 1228, 1143,  302,  196, 1249,   29,  139, 1671,  151,
- /*  1530 */  1213, 1801, 1227,   12,  515,   20,  511, 1684,   21,  521,
- /*  1540 */   273, 1656,  516, 1658, 1659,  512,  513,  533,   13,   41,
- /*  1550 */  1625,  231, 1655, 1312,  233,  235,   69, 1571,   70,  237,
- /*  1560 */  1687, 1644,  242,   74, 1230,  532, 1183, 1684, 1655,   44,
- /*  1570 */   272, 1656,  516, 1658, 1659,  512,  239,  533,  535, 1697,
- /*  1580 */  1671, 1061,  537,  314,  539,  541, 1058,  542,  514, 1055,
- /*  1590 */   544,  545,  547, 1049,  548,  550, 1671, 1047,  513, 1053,
- /*  1600 */   551, 1052, 1625, 1051,  514,  304, 1050, 1038, 1655,   75,
- /*  1610 */    76, 1069,   77,  557,  513, 1067, 1066,  965, 1625, 1684,
- /*  1620 */  1655,  306,  273, 1656,  516, 1658, 1659,  512,  565,  533,
- /*  1630 */   989, 1007,  244,  568,  987, 1684, 1671,  986,  273, 1656,
- /*  1640 */   516, 1658, 1659,  512,  514,  533,  985,  984, 1671,  983,
- /*  1650 */   982,  981,  980, 1004,  513, 1002,  514,  977, 1625,  976,
- /*  1660 */   975,  972,  971,  970, 1414,  589,  513,  590, 1655,  591,
- /*  1670 */  1625, 1412,  593,  595,  594, 1684, 1410,  597,  259, 1656,
- /*  1680 */   516, 1658, 1659,  512,  598,  533,  599, 1684, 1408,  601,
- /*  1690 */   267, 1656,  516, 1658, 1659,  512, 1671,  533,  602,  603,
- /*  1700 */  1655,  605,  606, 1395,  514, 1396, 1381,  609,  610, 1356,
- /*  1710 */  1356, 1169,  254,  613,  513,  614, 1356, 1356, 1625, 1356,
- /*  1720 */  1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1671, 1356,
- /*  1730 */  1655, 1356, 1356, 1356, 1356, 1684,  514, 1356,  269, 1656,
- /*  1740 */   516, 1658, 1659,  512, 1356,  533,  513, 1356, 1356, 1356,
- /*  1750 */  1625, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1671, 1356,
- /*  1760 */  1356, 1356, 1655, 1356, 1356, 1356,  514, 1684, 1356, 1356,
- /*  1770 */   260, 1656,  516, 1658, 1659,  512,  513,  533, 1655, 1356,
- /*  1780 */  1625, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356,
- /*  1790 */  1671, 1356, 1356, 1356, 1655, 1356, 1356, 1684,  514, 1356,
- /*  1800 */   270, 1656,  516, 1658, 1659,  512, 1671,  533,  513, 1356,
- /*  1810 */  1655, 1356, 1625, 1356,  514, 1356, 1356, 1356, 1356, 1356,
- /*  1820 */  1356, 1356, 1671, 1356,  513, 1356, 1356, 1356, 1625, 1684,
- /*  1830 */   514, 1356,  261, 1656,  516, 1658, 1659,  512, 1671,  533,
- /*  1840 */   513, 1356, 1356, 1356, 1625, 1684,  514, 1356,  271, 1656,
- /*  1850 */   516, 1658, 1659,  512, 1356,  533,  513, 1356, 1356, 1356,
- /*  1860 */  1625, 1684, 1655, 1356,  262, 1656,  516, 1658, 1659,  512,
- /*  1870 */  1356,  533, 1356, 1356, 1356, 1356, 1356, 1684, 1655, 1356,
- /*  1880 */  1667, 1656,  516, 1658, 1659,  512, 1356,  533, 1356, 1356,
- /*  1890 */  1671, 1356, 1356, 1356, 1356, 1356, 1356, 1356,  514, 1356,
- /*  1900 */  1356, 1356, 1356, 1356, 1356, 1356, 1671, 1356,  513, 1356,
- /*  1910 */  1655, 1356, 1625, 1356,  514, 1356, 1356, 1356, 1356, 1356,
- /*  1920 */  1356, 1356, 1356, 1356,  513, 1356, 1356, 1356, 1625, 1684,
- /*  1930 */  1356, 1356, 1666, 1656,  516, 1658, 1659,  512, 1671,  533,
- /*  1940 */  1356, 1356, 1655, 1356, 1356, 1684,  514, 1356, 1665, 1656,
- /*  1950 */   516, 1658, 1659,  512, 1356,  533,  513, 1356, 1356, 1356,
- /*  1960 */  1625, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356,
- /*  1970 */  1671, 1356, 1655, 1356, 1356, 1356, 1356, 1684,  514, 1356,
- /*  1980 */   282, 1656,  516, 1658, 1659,  512, 1356,  533,  513, 1356,
- /*  1990 */  1356, 1356, 1625, 1356, 1356, 1356, 1356, 1356, 1356, 1356,
- /*  2000 */  1671, 1356, 1356, 1356, 1655, 1356, 1356, 1356,  514, 1684,
- /*  2010 */  1356, 1356,  281, 1656,  516, 1658, 1659,  512,  513,  533,
- /*  2020 */  1655, 1356, 1625, 1356, 1356, 1356, 1356, 1356, 1356, 1356,
- /*  2030 */  1356, 1356, 1671, 1356, 1356, 1356, 1356, 1356, 1356, 1684,
- /*  2040 */   514, 1356,  283, 1656,  516, 1658, 1659,  512, 1671,  533,
- /*  2050 */   513,  490, 1356, 1356, 1625, 1356,  514, 1356, 1356,  490,
- /*  2060 */  1356, 1356, 1356, 1356, 1356, 1356,  513, 1356, 1356, 1356,
- /*  2070 */  1625, 1684, 1356, 1356,  280, 1656,  516, 1658, 1659,  512,
- /*  2080 */   114,  533, 1356, 1356, 1356, 1356, 1356, 1684,  114, 1356,
- /*  2090 */   266, 1656,  516, 1658, 1659,  512, 1356,  533, 1356,  494,
- /*  2100 */  1356, 1356, 1356, 1356, 1356, 1356, 1356,  494, 1356, 1356,
- /*  2110 */  1356, 1356, 1356, 1356, 1356, 1356, 1356, 1356,  112, 1356,
- /*  2120 */  1356, 1356, 1356, 1356, 1356, 1356,  112, 1356, 1356, 1356,
- /*  2130 */  1356, 1356, 1356,  219, 1731,  489, 1356,  488, 1356, 1356,
- /*  2140 */  1786,  219, 1731,  489, 1356,  488, 1356, 1356, 1786, 1356,
- /*  2150 */  1356, 1356,  149, 1356, 1356, 1356, 1783, 1356, 1356, 1356,
- /*  2160 */   147, 1356, 1356, 1356, 1783,
+ /*   220 */   130,  406,   36,   34,   32,   31,   30, 1170, 1171, 1490,
+ /*   230 */  1217, 1218, 1220, 1221, 1222, 1223, 1224,  508,  530, 1232,
+ /*   240 */  1233, 1234, 1235, 1236, 1237,   35,   33,  342,  484,  479,
+ /*   250 */  1354,  441,  440,  305, 1654, 1166,  439,  200,  252,  111,
+ /*   260 */   436, 1517,  378,  435,  434,  433,   35,   33,  289,  446,
+ /*   270 */   287,  286, 1000,  429,  305, 1478, 1166,  431,  129,  309,
+ /*   280 */  1164,   79, 1670,   55,  454,   66,  150,  130,  150, 1002,
+ /*   290 */   513,   14, 1204,  483,  115, 1638, 1489, 1172,  193,  430,
+ /*   300 */   512, 1164, 1479,  948, 1624,  947,  161,  160,  321,  493,
+ /*   310 */   449, 1634, 1640,  393,    2,  443, 1191, 1642, 1172, 1188,
+ /*   320 */   192, 1683,  532,  489,   82, 1655,  515, 1657, 1658,  511,
+ /*   330 */    24,  532,  949, 1349, 1723,    8,  611, 1638,  278, 1719,
+ /*   340 */    36,   34,   32,   31,   30,   51, 1165, 1463,   50, 1785,
+ /*   350 */  1785,  565,  114, 1634, 1640,   65,  294,  611, 1379,  194,
+ /*   360 */   558,  147,  147, 1462,  532, 1782, 1782, 1165, 1356, 1038,
+ /*   370 */   555,  554,  553, 1042,  552, 1044, 1045,  551, 1047,  548,
+ /*   380 */  1378, 1053,  545, 1055, 1056,  542,  539,    7,   55, 1167,
+ /*   390 */   112, 1189,  105,  104,  103,  102,  101,  100,   99,   98,
+ /*   400 */    97,   32,   31,   30,  565,  146, 1730, 1731, 1624, 1735,
+ /*   410 */  1167,  150, 1170, 1171, 1348, 1217, 1218, 1220, 1221, 1222,
+ /*   420 */  1223, 1224,  508,  530, 1232, 1233, 1234, 1235, 1236, 1237,
+ /*   430 */  1624,  568,  157, 1170, 1171,  462, 1217, 1218, 1220, 1221,
+ /*   440 */  1222, 1223, 1224,  508,  530, 1232, 1233, 1234, 1235, 1236,
+ /*   450 */  1237,   35,   33, 1238,   26, 1377,  563,   61,  465,  305,
+ /*   460 */    60, 1166,  563,  150,   36,   34,   32,   31,   30,   63,
+ /*   470 */  1405,  395,   35,   33,  391,  562, 1654,  561,  560,  559,
+ /*   480 */   305,  562, 1166,  561,  560,  559, 1164, 1192,  529, 1317,
+ /*   490 */   529, 1483,  442,   36,   34,   32,   31,   30, 1785, 1785,
+ /*   500 */   353, 1644,  106, 1172, 1670, 1624, 1472, 1164,   55,  432,
+ /*   510 */  1784,  147,  492,  455, 1782, 1782,  150, 1487, 1376, 1487,
+ /*   520 */     9,  569,  512, 1459, 1172, 1418, 1624,  453,  475, 1315,
+ /*   530 */  1316, 1318, 1319,   36,   34,   32,   31,   30, 1646,  279,
+ /*   540 */   451,    9,  611, 1683,  438,  437,   83, 1655,  515, 1657,
+ /*   550 */  1658,  511, 1165,  532, 1785, 1474, 1723, 1531, 1288,  315,
+ /*   560 */   298, 1719,  143,  611,  310, 1785,  147,  130, 1624, 1529,
+ /*   570 */  1782, 1255, 1300, 1165,  222, 1785, 1489,  148, 1190,  471,
+ /*   580 */  1750, 1782,  347, 1737,  346,  441,  440, 1783,  529,  339,
+ /*   590 */   439, 1782, 1531,  111,  436, 1167, 1531,  435,  434,  433,
+ /*   600 */   363,  581,  579,  316, 1530, 1568, 1569, 1734, 1529,  341,
+ /*   610 */   337, 1292,  221, 1375,  935,  936, 1167, 1487, 1170, 1171,
+ /*   620 */  1256, 1217, 1218, 1220, 1221, 1222, 1223, 1224,  508,  530,
+ /*   630 */  1232, 1233, 1234, 1235, 1236, 1237,  150,   11,   10, 1170,
+ /*   640 */  1171, 1261, 1217, 1218, 1220, 1221, 1222, 1223, 1224,  508,
+ /*   650 */   530, 1232, 1233, 1234, 1235, 1236, 1237,   35,   33,  276,
+ /*   660 */  1654, 1188,  529, 1624,  529,  305, 1374, 1166,  371,   54,
+ /*   670 */  1373,  383, 1372, 1470,  364,  197,  405,  507,   27,  303,
+ /*   680 */  1250, 1251, 1252, 1253, 1254, 1258, 1259, 1260, 1670,  384,
+ /*   690 */   529, 1487, 1164, 1487, 1243,  529,  513, 1371, 1564,  529,
+ /*   700 */  1190,  431, 1484, 1370,  318,  159,  512, 1603, 1190, 1172,
+ /*   710 */  1624,  463,  130,  529, 1150, 1151, 1624, 1193, 1269, 1487,
+ /*   720 */  1624, 1489, 1624,  430, 1487,  526,    2, 1683, 1487, 1257,
+ /*   730 */    83, 1655,  515, 1657, 1658,  511,  947,  532, 1367, 1366,
+ /*   740 */  1723, 1219, 1487,  497,  298, 1719, 1798, 1624,  611,  120,
+ /*   750 */  1262, 1742, 1288, 1624, 1365, 1757, 1364, 1363, 1165,  382,
+ /*   760 */  1362,  425,  377,  376,  375,  374,  373,  370,  369,  368,
+ /*   770 */   367,  366,  362,  361,  360,  359,  358,  357,  356,  355,
+ /*   780 */   529,  131,  529,  529, 1737, 1369,  258,   25, 1624, 1624,
+ /*   790 */   467, 1737,  527, 1361,  243,  319, 1360,  500,  256,   53,
+ /*   800 */  1613, 1167,   52, 1359, 1624,  505, 1624, 1624, 1733, 1487,
+ /*   810 */  1624, 1487, 1487,  185, 1445, 1732,  183, 1291,  187,  162,
+ /*   820 */   189,  186, 1175,  188, 1170, 1171,   46, 1217, 1218, 1220,
+ /*   830 */  1221, 1222, 1223, 1224,  508,  530, 1232, 1233, 1234, 1235,
+ /*   840 */  1236, 1237,  206, 1624,   55,  327, 1624,   36,   34,   32,
+ /*   850 */    31,   30,  191, 1624, 1400,  190, 1166, 1398,  209,   11,
+ /*   860 */    10, 1351, 1352, 1219,   46,   37,   37, 1314,   37,  232,
+ /*   870 */   557, 1219,  456,  118,  119,   78,  444,  120, 1174,  447,
+ /*   880 */    81, 1164,  537,  225,  972,   74,  119,  476, 1178,  120,
+ /*   890 */   495,  216, 1671,  279,  121, 1389, 1654, 1526, 1172,  211,
+ /*   900 */   424,  973,  119, 1753,  490,  251, 1263, 1225,  322, 1123,
+ /*   910 */   234,   59,   58,  351,  521,  240,  156, 1204, 1031, 1188,
+ /*   920 */   224,  345,    3, 1059, 1670, 1255, 1247, 1063,  498,  227,
+ /*   930 */  1069,  229,  492,  275,    5, 1067,  335,  611,  333,  329,
+ /*   940 */   153,  323,  512,  122, 1177,  326, 1624, 1165,  325,  284,
+ /*   950 */  1000,  285,  312,  311,  248, 1134,  158,  365, 1566,  372,
+ /*   960 */   380,  379, 1180, 1683,  381,  385,   83, 1655,  515, 1657,
+ /*   970 */  1658,  511,  150,  532, 1256, 1654, 1723, 1194, 1197,  386,
+ /*   980 */   298, 1719,  143,  394,  501,  397,  398, 1173, 1196,  399,
+ /*   990 */  1167,  165,  167, 1198,  170, 1261,  172,  403,  400,  402,
+ /*  1000 */  1751, 1195,  175, 1670, 1172,   62,  404,  407,  178,  426,
+ /*  1010 */  1172,  513,   86, 1170, 1171,  428,  293, 1477, 1607,  182,
+ /*  1020 */  1473,  512,  184,  124,  249, 1624,  125, 1475, 1654, 1471,
+ /*  1030 */   126,  127,   27,  303, 1250, 1251, 1252, 1253, 1254, 1258,
+ /*  1040 */  1259, 1260, 1683,  533,  195,   83, 1655,  515, 1657, 1658,
+ /*  1050 */   511,  457,  532, 1176,  198, 1723, 1670,  461,  464,  298,
+ /*  1060 */  1719, 1798,  201,  466,  513,  468,  458,  469,  477,  204,
+ /*  1070 */  1780, 1193, 1764,  207,  512,  519, 1763,  474, 1624, 1654,
+ /*  1080 */   297, 1754,  210,  480,  215,    6,  486, 1744,  473,  217,
+ /*  1090 */  1654, 1288,  113, 1192,   40, 1683, 1181,  502,   83, 1655,
+ /*  1100 */   515, 1657, 1658,  511, 1738,  532,  218, 1670, 1723,  137,
+ /*  1110 */   499,  299,  298, 1719, 1798,  513,   18,  517, 1670, 1184,
+ /*  1120 */   518, 1704, 1575, 1741, 1781,  512,  513,  223,  226, 1624,
+ /*  1130 */   530, 1232, 1233,  228,  493, 1574,  512, 1801, 1654,  522,
+ /*  1140 */  1624,  307,  236,  496,  523,  493, 1683,  238,  503,  263,
+ /*  1150 */  1655,  515, 1657, 1658,  511,  524,  532, 1683,  250,   71,
+ /*  1160 */   263, 1655,  515, 1657, 1658,  511, 1670,  532, 1488,   73,
+ /*  1170 */  1460,  535,  253,  245,  513, 1785,  610,   47, 1654,  255,
+ /*  1180 */   136,  264,  274,  265,  512, 1618, 1785,  149, 1624,  257,
+ /*  1190 */  1617, 1782,   57, 1616,  324, 1159, 1160,  154,  147,  328,
+ /*  1200 */  1612,  330, 1782,  331,  332, 1683, 1670, 1611,   84, 1655,
+ /*  1210 */   515, 1657, 1658,  511,  513,  532,  334, 1610, 1723,  336,
+ /*  1220 */   180, 1609, 1722, 1719,  512,  338, 1608,  340, 1624,  343,
+ /*  1230 */   344, 1137,  141, 1593,  155, 1136, 1587, 1654,  423,  419,
+ /*  1240 */   415,  411,  179, 1586,  349, 1683,  350, 1585,   84, 1655,
+ /*  1250 */   515, 1657, 1658,  511, 1584,  532, 1106, 1559, 1723,  117,
+ /*  1260 */  1541, 1540,  504, 1719, 1558, 1670, 1557,   64, 1556, 1555,
+ /*  1270 */   177, 1554, 1553,  510, 1552, 1551, 1550, 1549, 1548, 1547,
+ /*  1280 */  1546, 1545, 1544,  512, 1543, 1542, 1539, 1624, 1538, 1654,
+ /*  1290 */  1537, 1536, 1108, 1535, 1534, 1533, 1532, 1417, 1654, 1385,
+ /*  1300 */   108,  938,  163,  937, 1683, 1384,  140,  272, 1655,  515,
+ /*  1310 */  1657, 1658,  511,  509,  532,  506, 1695, 1670, 1601, 1595,
+ /*  1320 */  1583,  164,  171, 1582, 1572,  513, 1670,  176, 1466,  168,
+ /*  1330 */  1416,  173,  966,  401,  513,  512,  390,  109,  169, 1624,
+ /*  1340 */   174, 1414,  392,  410,  512, 1412,  414, 1410, 1624,  408,
+ /*  1350 */  1408,  166,  409,  418, 1654,  412, 1683,  413,  417,  134,
+ /*  1360 */  1655,  515, 1657, 1658,  511, 1683,  532,  421,   84, 1655,
+ /*  1370 */   515, 1657, 1658,  511,  422,  532,  416, 1397, 1723,  614,
+ /*  1380 */   420, 1396, 1670, 1720, 1383, 1468, 1073, 1072, 1467,  999,
+ /*  1390 */   513,  998,  578,  247,   45,  997,  996,  580,  181,  993,
+ /*  1400 */   512,  992,  494, 1799, 1624,  107,  991,  472, 1654, 1406,
+ /*  1410 */  1401,  603,  599,  595,  591,  246,  290, 1654,  291,  445,
+ /*  1420 */  1399, 1683,  292,  448,  273, 1655,  515, 1657, 1658,  511,
+ /*  1430 */  1382,  532, 1381,  450,  452,   85, 1670, 1600, 1144, 1594,
+ /*  1440 */    80,  459, 1581,  241,  513, 1670, 1580, 1579, 1571,   67,
+ /*  1450 */   203,   15,  208,  513,  512,    4, 1313,   37, 1624,   49,
+ /*  1460 */   460,  205,   48,  512,   43, 1306,  213, 1624,  199,   16,
+ /*  1470 */  1654,  135,  214,  212,   22, 1683,  525, 1644,  268, 1655,
+ /*  1480 */   515, 1657, 1658,  511, 1683,  532,  128,  134, 1655,  515,
+ /*  1490 */  1657, 1658,  511,   23,  532,  220,   42,  138, 1670,   68,
+ /*  1500 */  1654,  470,   17, 1285,  202, 1337,  513, 1336, 1284,  300,
+ /*  1510 */  1341, 1342, 1340, 1331,  301,  485,  512,   10,   19, 1248,
+ /*  1520 */  1624,   29, 1142,  302,  196, 1227, 1226,  139, 1670,  151,
+ /*  1530 */    12, 1800, 1212, 1570,  514,   20,  510, 1683,   41,  231,
+ /*  1540 */   273, 1655,  515, 1657, 1658,  511,  512,  532,   13,   21,
+ /*  1550 */  1624, 1311, 1654,  233,  235,   69,  237,   70, 1643, 1686,
+ /*  1560 */   520,   74,  239, 1229,  242,  531, 1182, 1683, 1654,   44,
+ /*  1570 */   272, 1655,  515, 1657, 1658,  511, 1060,  532,  534, 1696,
+ /*  1580 */  1670,  536,  314,  538, 1052, 1057,  540,  541,  513, 1054,
+ /*  1590 */   543, 1048,  544,  546,  547,  549, 1670,  550,  512, 1046,
+ /*  1600 */  1051, 1050, 1624, 1049,  513,  304, 1037,   75, 1654,   76,
+ /*  1610 */  1068,  556,   77, 1066,  512, 1065,  964,  564, 1624, 1683,
+ /*  1620 */  1654,  306,  273, 1655,  515, 1657, 1658,  511,  988,  532,
+ /*  1630 */  1006,  567,  244,  986,  985, 1683, 1670,  984,  273, 1655,
+ /*  1640 */   515, 1657, 1658,  511,  513,  532,  983,  982, 1670,  981,
+ /*  1650 */   980,  979, 1003, 1001,  512,  976,  513,  975, 1624,  974,
+ /*  1660 */   971,  970,  969, 1413,  588,  589,  512,  590, 1654,  592,
+ /*  1670 */  1624, 1411,  594,  593, 1409, 1683,  596,  597,  259, 1655,
+ /*  1680 */   515, 1657, 1658,  511,  598,  532, 1407, 1683,  600,  601,
+ /*  1690 */   267, 1655,  515, 1657, 1658,  511, 1670,  532,  602, 1395,
+ /*  1700 */  1654,  604,  605, 1394,  513, 1380,  608, 1168,  609,  613,
+ /*  1710 */   254,  612, 1355, 1355,  512, 1355, 1355, 1355, 1624, 1355,
+ /*  1720 */  1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1670, 1355,
+ /*  1730 */  1654, 1355, 1355, 1355, 1355, 1683,  513, 1355,  269, 1655,
+ /*  1740 */   515, 1657, 1658,  511, 1355,  532,  512, 1355, 1355, 1355,
+ /*  1750 */  1624, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1670, 1355,
+ /*  1760 */  1355, 1355, 1654, 1355, 1355, 1355,  513, 1683, 1355, 1355,
+ /*  1770 */   260, 1655,  515, 1657, 1658,  511,  512,  532, 1654, 1355,
+ /*  1780 */  1624, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
+ /*  1790 */  1670, 1355, 1355, 1355, 1654, 1355, 1355, 1683,  513, 1355,
+ /*  1800 */   270, 1655,  515, 1657, 1658,  511, 1670,  532,  512, 1355,
+ /*  1810 */  1654, 1355, 1624, 1355,  513, 1355, 1355, 1355, 1355, 1355,
+ /*  1820 */  1355, 1355, 1670, 1355,  512, 1355, 1355, 1355, 1624, 1683,
+ /*  1830 */   513, 1355,  261, 1655,  515, 1657, 1658,  511, 1670,  532,
+ /*  1840 */   512, 1355, 1355, 1355, 1624, 1683,  513, 1355,  271, 1655,
+ /*  1850 */   515, 1657, 1658,  511, 1355,  532,  512, 1355, 1355, 1355,
+ /*  1860 */  1624, 1683, 1654, 1355,  262, 1655,  515, 1657, 1658,  511,
+ /*  1870 */  1355,  532, 1355, 1355, 1355, 1355, 1355, 1683, 1654, 1355,
+ /*  1880 */  1666, 1655,  515, 1657, 1658,  511, 1355,  532, 1355, 1355,
+ /*  1890 */  1670, 1355, 1355, 1355, 1355, 1355, 1355, 1355,  513, 1355,
+ /*  1900 */  1355, 1355, 1355, 1355, 1355, 1355, 1670, 1355,  512, 1355,
+ /*  1910 */  1654, 1355, 1624, 1355,  513, 1355, 1355, 1355, 1355, 1355,
+ /*  1920 */  1355, 1355, 1355, 1355,  512, 1355, 1355, 1355, 1624, 1683,
+ /*  1930 */  1355, 1355, 1665, 1655,  515, 1657, 1658,  511, 1670,  532,
+ /*  1940 */  1355, 1355, 1654, 1355, 1355, 1683,  513, 1355, 1664, 1655,
+ /*  1950 */   515, 1657, 1658,  511, 1355,  532,  512, 1355, 1355, 1355,
+ /*  1960 */  1624, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
+ /*  1970 */  1670, 1355, 1654, 1355, 1355, 1355, 1355, 1683,  513, 1355,
+ /*  1980 */   282, 1655,  515, 1657, 1658,  511, 1355,  532,  512, 1355,
+ /*  1990 */  1355, 1355, 1624, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
+ /*  2000 */  1670, 1355, 1355, 1355, 1654, 1355, 1355, 1355,  513, 1683,
+ /*  2010 */  1355, 1355,  281, 1655,  515, 1657, 1658,  511,  512,  532,
+ /*  2020 */  1654, 1355, 1624, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
+ /*  2030 */  1355, 1355, 1670, 1355, 1355, 1355, 1355, 1355, 1355, 1683,
+ /*  2040 */   513, 1355,  283, 1655,  515, 1657, 1658,  511, 1670,  532,
+ /*  2050 */   512,  489, 1355, 1355, 1624, 1355,  513, 1355, 1355,  489,
+ /*  2060 */  1355, 1355, 1355, 1355, 1355, 1355,  512, 1355, 1355, 1355,
+ /*  2070 */  1624, 1683, 1355, 1355,  280, 1655,  515, 1657, 1658,  511,
+ /*  2080 */   114,  532, 1355, 1355, 1355, 1355, 1355, 1683,  114, 1355,
+ /*  2090 */   266, 1655,  515, 1657, 1658,  511, 1355,  532, 1355,  493,
+ /*  2100 */  1355, 1355, 1355, 1355, 1355, 1355, 1355,  493, 1355, 1355,
+ /*  2110 */  1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355,  112, 1355,
+ /*  2120 */  1355, 1355, 1355, 1355, 1355, 1355,  112, 1355, 1355, 1355,
+ /*  2130 */  1355, 1355, 1355,  219, 1730,  488, 1355,  487, 1355, 1355,
+ /*  2140 */  1785,  219, 1730,  488, 1355,  487, 1355, 1355, 1785, 1355,
+ /*  2150 */  1355, 1355,  149, 1355, 1355, 1355, 1782, 1355, 1355, 1355,
+ /*  2160 */   147, 1355, 1355, 1355, 1782,
 };
 static const YYCODETYPE yy_lookahead[] = {
  /*     0 */   251,  248,  241,  271,  322,  323,  274,    0,  271,  249,
@@ -555,59 +555,59 @@ static const YYCODETYPE yy_lookahead[] = {
  /*  1160 */   311,  312,  313,  314,  315,  316,  269,  318,  277,   81,
  /*  1170 */   259,  273,  248,  251,  277,  337,  243,  299,  241,  252,
  /*  1180 */   303,  263,  263,  263,  287,    0,  337,  349,  291,  239,
- /*  1190 */     0,  353,   40,    0,   72,    0,   47,  174,  349,  174,
- /*  1200 */    47,   47,  353,   47,    0,  308,  269,   47,  311,  312,
- /*  1210 */   313,  314,  315,  316,  277,  318,   47,  174,  321,    0,
- /*  1220 */    33,   47,  325,  326,  287,    0,   47,    0,  291,   47,
- /*  1230 */     0,   81,   45,  113,  160,  159,  156,  241,   51,   52,
- /*  1240 */    53,   54,   55,    0,    0,  308,  152,  151,  311,  312,
- /*  1250 */   313,  314,  315,  316,    0,  318,    0,   44,  321,   22,
- /*  1260 */    40,    0,  325,  326,    0,  269,    0,   80,    0,    0,
+ /*  1190 */     0,  353,   40,    0,   72,   47,   47,   47,  349,  174,
+ /*  1200 */     0,   47,  353,   47,  174,  308,  269,    0,  311,  312,
+ /*  1210 */   313,  314,  315,  316,  277,  318,  174,    0,  321,   47,
+ /*  1220 */    33,    0,  325,  326,  287,   47,    0,   47,  291,  160,
+ /*  1230 */   159,  113,   45,    0,   81,  156,    0,  241,   51,   52,
+ /*  1240 */    53,   54,   55,    0,  152,  308,  151,    0,  311,  312,
+ /*  1250 */   313,  314,  315,  316,    0,  318,   44,    0,  321,   40,
+ /*  1260 */     0,    0,  325,  326,    0,  269,    0,   80,    0,    0,
  /*  1270 */    83,    0,    0,  277,    0,    0,    0,    0,    0,    0,
  /*  1280 */     0,    0,    0,  287,    0,    0,    0,  291,    0,  241,
- /*  1290 */     0,    0,    0,    0,    0,    0,    0,    0,  241,    0,
- /*  1300 */     0,   41,   40,   14,  308,    0,    0,  311,  312,  313,
- /*  1310 */   314,  315,  316,  317,  318,  319,  320,  269,   14,    0,
- /*  1320 */    37,    0,  147,    0,   37,  277,  269,  140,    0,  142,
- /*  1330 */     0,  144,   59,  146,  277,  287,    0,    0,    0,  291,
- /*  1340 */    38,    0,   44,    0,  287,   44,   37,   37,  291,   37,
- /*  1350 */    47,  164,   45,   37,  241,   47,  308,    0,   45,  311,
- /*  1360 */   312,  313,  314,  315,  316,  308,  318,   47,  311,  312,
- /*  1370 */   313,  314,  315,  316,   45,  318,   37,   45,  321,   19,
- /*  1380 */    47,   37,  269,  326,    0,    0,    0,   47,   22,    0,
- /*  1390 */   277,   41,   47,   33,   47,   47,   47,   41,   47,   47,
- /*  1400 */   287,   47,  354,  355,  291,   45,   88,  294,  241,    0,
- /*  1410 */    22,   51,   52,   53,   54,   55,   90,  241,    0,   22,
- /*  1420 */    48,  308,    0,   22,  311,  312,  313,  314,  315,  316,
- /*  1430 */    47,  318,    0,   22,    0,   22,  269,   20,    0,   47,
- /*  1440 */    80,    0,   22,   83,  277,  269,    0,    0,    0,    0,
- /*  1450 */    81,   37,  213,  277,  287,   82,   41,   41,  291,  145,
- /*  1460 */   145,   81,  145,  287,  142,   41,   41,  291,  213,   82,
- /*  1470 */   241,  140,   81,   44,   81,  308,  116,   82,  311,  312,
+ /*  1290 */     0,    0,   22,    0,    0,    0,    0,    0,  241,    0,
+ /*  1300 */    37,   14,   40,   14,  308,    0,   41,  311,  312,  313,
+ /*  1310 */   314,  315,  316,  317,  318,  319,  320,  269,    0,    0,
+ /*  1320 */     0,   38,  147,    0,    0,  277,  269,  140,    0,  142,
+ /*  1330 */     0,  144,   59,  146,  277,  287,   44,   37,   37,  291,
+ /*  1340 */    37,    0,   44,   37,  287,    0,   37,    0,  291,   47,
+ /*  1350 */     0,  164,   45,   37,  241,   47,  308,   45,   45,  311,
+ /*  1360 */   312,  313,  314,  315,  316,  308,  318,   45,  311,  312,
+ /*  1370 */   313,  314,  315,  316,   37,  318,   47,    0,  321,   19,
+ /*  1380 */    47,    0,  269,  326,    0,    0,   47,   22,    0,   47,
+ /*  1390 */   277,   47,   41,   33,   90,   47,   47,   41,   88,   47,
+ /*  1400 */   287,   47,  354,  355,  291,   45,   47,  294,  241,    0,
+ /*  1410 */     0,   51,   52,   53,   54,   55,   22,  241,   22,   48,
+ /*  1420 */     0,  308,   22,   47,  311,  312,  313,  314,  315,  316,
+ /*  1430 */     0,  318,    0,   22,   22,   20,  269,    0,   47,    0,
+ /*  1440 */    80,   22,    0,   83,  277,  269,    0,    0,    0,   81,
+ /*  1450 */    37,  213,   82,  277,  287,   41,   82,   41,  291,  145,
+ /*  1460 */   145,  140,  145,  287,   41,   82,   41,  291,  142,  213,
+ /*  1470 */   241,   81,   44,   81,   81,  308,  116,   44,  311,  312,
  /*  1480 */   313,  314,  315,  316,  308,  318,  161,  311,  312,  313,
- /*  1490 */   314,  315,  316,   81,  318,   44,   41,   44,  269,   41,
- /*  1500 */   241,  141,   41,   82,  144,   82,  277,   44,   82,   47,
- /*  1510 */    82,   47,   47,   47,   47,  348,  287,   47,    2,   41,
- /*  1520 */   291,   82,  162,  294,  164,  179,   81,   44,  269,   44,
- /*  1530 */    22,  355,   82,   81,  181,   81,  277,  308,   81,  143,
- /*  1540 */   311,  312,  313,  314,  315,  316,  287,  318,  213,  207,
- /*  1550 */   291,   82,  241,   82,   81,   81,   81,    0,   81,   37,
- /*  1560 */    81,   44,   44,   91,   82,   81,   22,  308,  241,   81,
- /*  1570 */   311,  312,  313,  314,  315,  316,  140,  318,   92,  320,
- /*  1580 */   269,   82,   47,   47,   81,   47,   82,   81,  277,   82,
- /*  1590 */    47,   81,   47,   82,   81,   47,  269,   82,  287,  105,
- /*  1600 */    81,  105,  291,  105,  277,  294,  105,   22,  241,   81,
- /*  1610 */    81,   47,   81,   93,  287,  113,   22,   59,  291,  308,
- /*  1620 */   241,  294,  311,  312,  313,  314,  315,  316,   58,  318,
- /*  1630 */    47,   64,   41,   79,   47,  308,  269,   47,  311,  312,
- /*  1640 */   313,  314,  315,  316,  277,  318,   47,   47,  269,   47,
- /*  1650 */    22,   47,   47,   64,  287,   47,  277,   47,  291,   47,
- /*  1660 */    47,   47,   47,   47,    0,   47,  287,   45,  241,   37,
- /*  1670 */   291,    0,   47,   37,   45,  308,    0,   47,  311,  312,
- /*  1680 */   313,  314,  315,  316,   45,  318,   37,  308,    0,   47,
- /*  1690 */   311,  312,  313,  314,  315,  316,  269,  318,   45,   37,
- /*  1700 */   241,   47,   46,    0,  277,    0,    0,   22,   21,  358,
- /*  1710 */   358,   22,   22,   21,  287,   20,  358,  358,  291,  358,
+ /*  1490 */   314,  315,  316,   41,  318,   44,   41,   44,  269,   81,
+ /*  1500 */   241,  141,   41,   82,  144,   47,  277,   47,   82,   47,
+ /*  1510 */    47,   82,   47,   82,   47,  348,  287,    2,   41,  179,
+ /*  1520 */   291,   81,  162,  294,  164,   82,   82,   44,  269,   44,
+ /*  1530 */    81,  355,   22,    0,  181,   81,  277,  308,  207,   82,
+ /*  1540 */   311,  312,  313,  314,  315,  316,  287,  318,  213,   81,
+ /*  1550 */   291,   82,  241,   81,   81,   81,   37,   81,   44,   81,
+ /*  1560 */   143,   91,  140,   82,   44,   81,   22,  308,  241,   81,
+ /*  1570 */   311,  312,  313,  314,  315,  316,   82,  318,   92,  320,
+ /*  1580 */   269,   47,   47,   81,  105,   82,   47,   81,  277,   82,
+ /*  1590 */    47,   82,   81,   47,   81,   47,  269,   81,  287,   82,
+ /*  1600 */   105,  105,  291,  105,  277,  294,   22,   81,  241,   81,
+ /*  1610 */    47,   93,   81,  113,  287,   22,   59,   58,  291,  308,
+ /*  1620 */   241,  294,  311,  312,  313,  314,  315,  316,   47,  318,
+ /*  1630 */    64,   79,   41,   47,   47,  308,  269,   47,  311,  312,
+ /*  1640 */   313,  314,  315,  316,  277,  318,   47,   47,  269,   22,
+ /*  1650 */    47,   47,   64,   47,  287,   47,  277,   47,  291,   47,
+ /*  1660 */    47,   47,   47,    0,   47,   45,  287,   37,  241,   47,
+ /*  1670 */   291,    0,   37,   45,    0,  308,   47,   45,  311,  312,
+ /*  1680 */   313,  314,  315,  316,   37,  318,    0,  308,   47,   45,
+ /*  1690 */   311,  312,  313,  314,  315,  316,  269,  318,   37,    0,
+ /*  1700 */   241,   47,   46,    0,  277,    0,   22,   22,   21,   20,
+ /*  1710 */    22,   21,  358,  358,  287,  358,  358,  358,  291,  358,
  /*  1720 */   358,  358,  358,  358,  358,  358,  358,  358,  269,  358,
  /*  1730 */   241,  358,  358,  358,  358,  308,  277,  358,  311,  312,
  /*  1740 */   313,  314,  315,  316,  358,  318,  287,  358,  358,  358,
@@ -654,9 +654,9 @@ static const YYCODETYPE yy_lookahead[] = {
  /*  2150 */   358,  358,  349,  358,  358,  358,  353,  358,  358,  358,
  /*  2160 */   349,  358,  358,  358,  353,
 };
-#define YY_SHIFT_COUNT    (615)
+#define YY_SHIFT_COUNT    (614)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1706)
+#define YY_SHIFT_MAX      (1705)
 static const unsigned short int yy_shift_ofst[] = {
  /*     0 */   763,    0,    0,   48,  233,  233,  233,  233,  254,  254,
  /*    10 */   233,  233,  439,  460,  645,  460,  460,  460,  460,  460,
@@ -690,36 +690,36 @@ static const unsigned short int yy_shift_ofst[] = {
  /*   290 */   470,  854,  857,  506,  547,  708,  785,  817,  858,  667,
  /*   300 */   702,  756,  824,  747,  825,  457,  827,  828,  832,  833,
  /*   310 */   836,  775,  831,  823,  841,  845,  848,  853,  861,  794,
- /*   320 */   837, 1185, 1190, 1152, 1193, 1122, 1195, 1149, 1023, 1153,
- /*   330 */  1154, 1156, 1025, 1204, 1160, 1169, 1043, 1219, 1174, 1225,
- /*   340 */  1179, 1227, 1182, 1230, 1150, 1074, 1076, 1120, 1080, 1243,
- /*   350 */  1244, 1094, 1096, 1254, 1256, 1213, 1264, 1266, 1268, 1269,
+ /*   320 */   837, 1185, 1190, 1152, 1193, 1122, 1148, 1149, 1150, 1025,
+ /*   330 */  1200, 1154, 1156, 1030, 1207, 1042, 1217, 1172, 1221, 1178,
+ /*   340 */  1226, 1180, 1233, 1153, 1069, 1071, 1118, 1079, 1236, 1243,
+ /*   350 */  1092, 1095, 1247, 1254, 1212, 1257, 1264, 1266, 1268, 1269,
  /*   360 */  1271, 1272, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
- /*   370 */  1282, 1284, 1285, 1286, 1220, 1261, 1288, 1290, 1291, 1292,
- /*   380 */  1293, 1237, 1294, 1295, 1296, 1297, 1299, 1300, 1262, 1283,
- /*   390 */  1260, 1289, 1298, 1304, 1301, 1305, 1302, 1287, 1306, 1319,
- /*   400 */  1321, 1309, 1175, 1323, 1328, 1310, 1330, 1273, 1336, 1337,
- /*   410 */  1303, 1307, 1312, 1338, 1308, 1313, 1316, 1341, 1320, 1329,
- /*   420 */  1339, 1343, 1333, 1332, 1344, 1357, 1384, 1385, 1386, 1326,
- /*   430 */  1318, 1340, 1366, 1389, 1345, 1347, 1348, 1349, 1350, 1356,
- /*   440 */  1351, 1352, 1354, 1409, 1388, 1418, 1397, 1372, 1422, 1401,
- /*   450 */  1383, 1432, 1411, 1434, 1413, 1417, 1438, 1314, 1392, 1441,
- /*   460 */  1325, 1420, 1315, 1322, 1446, 1447, 1448, 1317, 1449, 1369,
- /*   470 */  1414, 1331, 1415, 1416, 1239, 1373, 1424, 1387, 1380, 1391,
- /*   480 */  1393, 1395, 1425, 1429, 1451, 1412, 1455, 1255, 1421, 1423,
- /*   490 */  1453, 1342, 1458, 1463, 1426, 1461, 1335, 1428, 1462, 1464,
- /*   500 */  1465, 1466, 1467, 1470, 1428, 1516, 1346, 1478, 1439, 1445,
- /*   510 */  1450, 1483, 1452, 1454, 1485, 1508, 1353, 1457, 1469, 1471,
- /*   520 */  1473, 1474, 1396, 1475, 1557, 1522, 1436, 1477, 1472, 1517,
- /*   530 */  1518, 1479, 1482, 1484, 1544, 1488, 1486, 1499, 1535, 1536,
- /*   540 */  1503, 1504, 1538, 1506, 1507, 1543, 1510, 1511, 1545, 1513,
- /*   550 */  1515, 1548, 1519, 1494, 1496, 1498, 1501, 1585, 1520, 1528,
- /*   560 */  1529, 1564, 1531, 1502, 1594, 1558, 1570, 1583, 1567, 1554,
- /*   570 */  1591, 1587, 1590, 1599, 1600, 1602, 1628, 1604, 1605, 1589,
- /*   580 */  1350, 1608, 1356, 1610, 1612, 1613, 1614, 1615, 1616, 1664,
- /*   590 */  1618, 1622, 1632, 1671, 1625, 1629, 1636, 1676, 1630, 1639,
- /*   600 */  1649, 1688, 1642, 1653, 1662, 1705, 1654, 1656, 1703, 1706,
- /*   610 */  1685, 1687, 1689, 1690, 1692, 1695,
+ /*   370 */  1282, 1284, 1285, 1219, 1260, 1261, 1286, 1288, 1290, 1291,
+ /*   380 */  1270, 1293, 1294, 1295, 1296, 1297, 1299, 1262, 1263, 1265,
+ /*   390 */  1287, 1292, 1289, 1298, 1305, 1283, 1300, 1318, 1319, 1320,
+ /*   400 */  1301, 1175, 1323, 1324, 1303, 1328, 1273, 1330, 1341, 1302,
+ /*   410 */  1307, 1306, 1345, 1308, 1312, 1309, 1347, 1329, 1313, 1316,
+ /*   420 */  1350, 1333, 1322, 1337, 1377, 1381, 1384, 1385, 1304, 1310,
+ /*   430 */  1339, 1365, 1388, 1342, 1344, 1348, 1349, 1351, 1356, 1352,
+ /*   440 */  1354, 1359, 1409, 1394, 1410, 1396, 1371, 1420, 1400, 1376,
+ /*   450 */  1430, 1411, 1432, 1412, 1415, 1437, 1314, 1391, 1439, 1325,
+ /*   460 */  1419, 1315, 1326, 1442, 1446, 1447, 1317, 1448, 1368, 1413,
+ /*   470 */  1321, 1414, 1416, 1238, 1370, 1423, 1374, 1390, 1392, 1393,
+ /*   480 */  1383, 1425, 1428, 1433, 1418, 1452, 1256, 1421, 1426, 1451,
+ /*   490 */  1331, 1455, 1453, 1429, 1461, 1335, 1431, 1458, 1460, 1462,
+ /*   500 */  1463, 1465, 1467, 1431, 1515, 1340, 1477, 1443, 1440, 1444,
+ /*   510 */  1483, 1449, 1454, 1485, 1510, 1353, 1468, 1457, 1469, 1472,
+ /*   520 */  1473, 1417, 1474, 1533, 1519, 1422, 1476, 1470, 1514, 1520,
+ /*   530 */  1478, 1481, 1484, 1544, 1488, 1486, 1494, 1534, 1535, 1502,
+ /*   540 */  1503, 1539, 1506, 1507, 1543, 1511, 1509, 1546, 1513, 1517,
+ /*   550 */  1548, 1516, 1479, 1495, 1496, 1498, 1584, 1518, 1526, 1528,
+ /*   560 */  1563, 1531, 1500, 1593, 1557, 1559, 1581, 1566, 1552, 1591,
+ /*   570 */  1586, 1587, 1590, 1599, 1600, 1627, 1603, 1604, 1588, 1351,
+ /*   580 */  1606, 1356, 1608, 1610, 1612, 1613, 1614, 1615, 1663, 1617,
+ /*   590 */  1620, 1630, 1671, 1622, 1628, 1635, 1674, 1629, 1632, 1647,
+ /*   600 */  1686, 1641, 1644, 1661, 1699, 1654, 1656, 1703, 1705, 1684,
+ /*   610 */  1687, 1685, 1688, 1690, 1689,
 };
 #define YY_REDUCE_COUNT (254)
 #define YY_REDUCE_MIN   (-318)
@@ -753,68 +753,68 @@ static const short yy_reduce_ofst[] = {
  /*   250 */   918,  919,  920,  927,  950,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    10 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    20 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    30 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    40 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    50 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    60 */  1354, 1354, 1354, 1354, 1423, 1354, 1354, 1354, 1354, 1354,
- /*    70 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    80 */  1421, 1561, 1354, 1726, 1354, 1354, 1354, 1354, 1354, 1354,
- /*    90 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   100 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   110 */  1423, 1354, 1737, 1737, 1737, 1421, 1354, 1354, 1354, 1354,
- /*   120 */  1354, 1354, 1517, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   130 */  1354, 1597, 1354, 1354, 1803, 1354, 1603, 1761, 1354, 1354,
- /*   140 */  1354, 1354, 1470, 1753, 1729, 1743, 1730, 1788, 1788, 1788,
- /*   150 */  1746, 1354, 1757, 1354, 1354, 1354, 1589, 1354, 1354, 1566,
- /*   160 */  1563, 1563, 1354, 1354, 1354, 1354, 1423, 1354, 1423, 1354,
- /*   170 */  1354, 1423, 1354, 1423, 1354, 1354, 1423, 1423, 1354, 1423,
- /*   180 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   190 */  1354, 1354, 1354, 1354, 1354, 1354, 1421, 1599, 1354, 1421,
- /*   200 */  1354, 1354, 1421, 1354, 1354, 1421, 1354, 1768, 1766, 1354,
- /*   210 */  1768, 1766, 1354, 1354, 1354, 1780, 1776, 1759, 1757, 1743,
- /*   220 */  1354, 1354, 1354, 1794, 1790, 1806, 1794, 1790, 1794, 1790,
- /*   230 */  1354, 1766, 1354, 1354, 1766, 1354, 1574, 1354, 1354, 1421,
- /*   240 */  1354, 1421, 1354, 1486, 1354, 1354, 1421, 1354, 1591, 1605,
- /*   250 */  1520, 1520, 1520, 1424, 1359, 1354, 1354, 1354, 1354, 1354,
- /*   260 */  1354, 1354, 1354, 1354, 1354, 1354, 1670, 1779, 1778, 1702,
- /*   270 */  1701, 1700, 1698, 1669, 1482, 1354, 1354, 1354, 1354, 1354,
- /*   280 */  1663, 1664, 1662, 1661, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   290 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1727, 1354,
- /*   300 */  1791, 1795, 1354, 1354, 1354, 1646, 1354, 1354, 1354, 1354,
- /*   310 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   320 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   330 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   340 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   350 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   360 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   370 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   380 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   390 */  1388, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   400 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   410 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   420 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   430 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1451, 1450,
- /*   440 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   450 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   460 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   470 */  1354, 1354, 1750, 1760, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   480 */  1354, 1354, 1354, 1354, 1646, 1354, 1777, 1354, 1736, 1732,
- /*   490 */  1354, 1354, 1728, 1354, 1354, 1789, 1354, 1354, 1354, 1354,
- /*   500 */  1354, 1354, 1354, 1354, 1354, 1722, 1354, 1695, 1354, 1354,
- /*   510 */  1354, 1354, 1354, 1354, 1354, 1354, 1657, 1354, 1354, 1354,
- /*   520 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1645,
- /*   530 */  1354, 1686, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   540 */  1514, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   550 */  1354, 1354, 1354, 1499, 1497, 1496, 1495, 1354, 1492, 1354,
- /*   560 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   570 */  1443, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   580 */  1434, 1354, 1433, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   590 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   600 */  1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354, 1354,
- /*   610 */  1354, 1354, 1354, 1354, 1354, 1354,
+ /*     0 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    10 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    20 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    30 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    40 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    50 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    60 */  1353, 1353, 1353, 1353, 1422, 1353, 1353, 1353, 1353, 1353,
+ /*    70 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    80 */  1420, 1560, 1353, 1725, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*    90 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   100 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   110 */  1422, 1353, 1736, 1736, 1736, 1420, 1353, 1353, 1353, 1353,
+ /*   120 */  1353, 1353, 1516, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   130 */  1353, 1596, 1353, 1353, 1802, 1353, 1602, 1760, 1353, 1353,
+ /*   140 */  1353, 1353, 1469, 1752, 1728, 1742, 1729, 1787, 1787, 1787,
+ /*   150 */  1745, 1353, 1756, 1353, 1353, 1353, 1588, 1353, 1353, 1565,
+ /*   160 */  1562, 1562, 1353, 1353, 1353, 1353, 1422, 1353, 1422, 1353,
+ /*   170 */  1353, 1422, 1353, 1422, 1353, 1353, 1422, 1422, 1353, 1422,
+ /*   180 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   190 */  1353, 1353, 1353, 1353, 1353, 1353, 1420, 1598, 1353, 1420,
+ /*   200 */  1353, 1353, 1420, 1353, 1353, 1420, 1353, 1767, 1765, 1353,
+ /*   210 */  1767, 1765, 1353, 1353, 1353, 1779, 1775, 1758, 1756, 1742,
+ /*   220 */  1353, 1353, 1353, 1793, 1789, 1805, 1793, 1789, 1793, 1789,
+ /*   230 */  1353, 1765, 1353, 1353, 1765, 1353, 1573, 1353, 1353, 1420,
+ /*   240 */  1353, 1420, 1353, 1485, 1353, 1353, 1420, 1353, 1590, 1604,
+ /*   250 */  1519, 1519, 1519, 1423, 1358, 1353, 1353, 1353, 1353, 1353,
+ /*   260 */  1353, 1353, 1353, 1353, 1353, 1353, 1669, 1778, 1777, 1701,
+ /*   270 */  1700, 1699, 1697, 1668, 1481, 1353, 1353, 1353, 1353, 1353,
+ /*   280 */  1662, 1663, 1661, 1660, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   290 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1726, 1353,
+ /*   300 */  1790, 1794, 1353, 1353, 1353, 1645, 1353, 1353, 1353, 1353,
+ /*   310 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   320 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   330 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   340 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   350 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   360 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   370 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   380 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1387,
+ /*   390 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   400 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   410 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   420 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   430 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1450, 1449, 1353,
+ /*   440 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   450 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   460 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   470 */  1353, 1749, 1759, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   480 */  1353, 1353, 1353, 1645, 1353, 1776, 1353, 1735, 1731, 1353,
+ /*   490 */  1353, 1727, 1353, 1353, 1788, 1353, 1353, 1353, 1353, 1353,
+ /*   500 */  1353, 1353, 1353, 1353, 1721, 1353, 1694, 1353, 1353, 1353,
+ /*   510 */  1353, 1353, 1353, 1353, 1353, 1656, 1353, 1353, 1353, 1353,
+ /*   520 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1644, 1353,
+ /*   530 */  1685, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1513,
+ /*   540 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   550 */  1353, 1353, 1498, 1496, 1495, 1494, 1353, 1491, 1353, 1353,
+ /*   560 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1442,
+ /*   570 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1433,
+ /*   580 */  1353, 1432, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   590 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   600 */  1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353,
+ /*   610 */  1353, 1353, 1353, 1353, 1353,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1007,10 +1007,10 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*       KILL => nothing */
     0,  /* CONNECTION => nothing */
     0,  /* TRANSACTION => nothing */
-    0,  /*      MERGE => nothing */
+    0,  /*    BALANCE => nothing */
     0,  /*     VGROUP => nothing */
+    0,  /*      MERGE => nothing */
     0,  /* REDISTRIBUTE => nothing */
-    0,  /*      SPLIT => nothing */
     0,  /*     SYNCDB => nothing */
     0,  /*     DELETE => nothing */
     0,  /*       NULL => nothing */
@@ -1332,10 +1332,10 @@ static const char *const yyTokenName[] = {
   /*  170 */ "KILL",
   /*  171 */ "CONNECTION",
   /*  172 */ "TRANSACTION",
-  /*  173 */ "MERGE",
+  /*  173 */ "BALANCE",
   /*  174 */ "VGROUP",
-  /*  175 */ "REDISTRIBUTE",
-  /*  176 */ "SPLIT",
+  /*  175 */ "MERGE",
+  /*  176 */ "REDISTRIBUTE",
   /*  177 */ "SYNCDB",
   /*  178 */ "DELETE",
   /*  179 */ "NULL",
@@ -1779,9 +1779,9 @@ static const char *const yyRuleName[] = {
  /* 252 */ "cmd ::= KILL CONNECTION NK_INTEGER",
  /* 253 */ "cmd ::= KILL QUERY NK_INTEGER",
  /* 254 */ "cmd ::= KILL TRANSACTION NK_INTEGER",
- /* 255 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
- /* 256 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
- /* 257 */ "cmd ::= SPLIT VGROUP NK_INTEGER",
+ /* 255 */ "cmd ::= BALANCE VGROUP",
+ /* 256 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
+ /* 257 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
  /* 258 */ "dnode_list ::= DNODE NK_INTEGER",
  /* 259 */ "dnode_list ::= dnode_list DNODE NK_INTEGER",
  /* 260 */ "cmd ::= SYNCDB db_name REPLICA",
@@ -2823,9 +2823,9 @@ static const struct {
   {  238,   -3 }, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
   {  238,   -3 }, /* (253) cmd ::= KILL QUERY NK_INTEGER */
   {  238,   -3 }, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
-  {  238,   -4 }, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-  {  238,   -4 }, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-  {  238,   -3 }, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
+  {  238,   -2 }, /* (255) cmd ::= BALANCE VGROUP */
+  {  238,   -4 }, /* (256) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+  {  238,   -4 }, /* (257) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
   {  305,   -2 }, /* (258) dnode_list ::= DNODE NK_INTEGER */
   {  305,   -3 }, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
   {  238,   -3 }, /* (260) cmd ::= SYNCDB db_name REPLICA */
@@ -3900,15 +3900,15 @@ static YYACTIONTYPE yy_reduce(
       case 254: /* cmd ::= KILL TRANSACTION NK_INTEGER */
 { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); }
         break;
-      case 255: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+      case 255: /* cmd ::= BALANCE VGROUP */
+{ pCxt->pRootNode = createBalanceVgroupStmt(pCxt); }
+        break;
+      case 256: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
 { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
         break;
-      case 256: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+      case 257: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
 { pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy60); }
         break;
-      case 257: /* cmd ::= SPLIT VGROUP NK_INTEGER */
-{ pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); }
-        break;
       case 258: /* dnode_list ::= DNODE NK_INTEGER */
 { yymsp[-1].minor.yy60 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
         break;
diff --git a/source/libs/parser/test/parExplainToSyncdbTest.cpp b/source/libs/parser/test/parExplainToSyncdbTest.cpp
index a040721031..4a5a92e621 100644
--- a/source/libs/parser/test/parExplainToSyncdbTest.cpp
+++ b/source/libs/parser/test/parExplainToSyncdbTest.cpp
@@ -19,7 +19,7 @@ using namespace std;
 
 namespace ParserTest {
 
-class ParserExplainToSyncdbTest : public ParserTestBase {};
+class ParserExplainToSyncdbTest : public ParserDdlTest {};
 
 TEST_F(ParserExplainToSyncdbTest, explain) {
   useDb("root", "test");
@@ -43,8 +43,62 @@ TEST_F(ParserExplainToSyncdbTest, grant) {
 // todo kill connection
 // todo kill query
 // todo kill stream
-// todo merge vgroup
-// todo redistribute vgroup
+
+TEST_F(ParserExplainToSyncdbTest, mergeVgroup) {
+  useDb("root", "test");
+
+  SMergeVgroupReq expect = {0};
+
+  auto setMergeVgroupReqFunc = [&](int32_t vgId1, int32_t vgId2) {
+    expect.vgId1 = vgId1;
+    expect.vgId2 = vgId2;
+  };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_MERGE_VGROUP_STMT);
+    ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_MERGE_VGROUP);
+    SMergeVgroupReq req = {0};
+    ASSERT_EQ(tDeserializeSMergeVgroupReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+    ASSERT_EQ(req.vgId1, expect.vgId1);
+    ASSERT_EQ(req.vgId2, expect.vgId2);
+  });
+
+  setMergeVgroupReqFunc(1, 2);
+  run("MERGE VGROUP 1 2");
+}
+
+TEST_F(ParserExplainToSyncdbTest, redistributeVgroup) {
+  useDb("root", "test");
+
+  SRedistributeVgroupReq expect = {0};
+
+  auto setRedistributeVgroupReqFunc = [&](int32_t vgId, int32_t dnodeId1, int32_t dnodeId2 = -1,
+                                          int32_t dnodeId3 = -1) {
+    expect.vgId = vgId;
+    expect.dnodeId1 = dnodeId1;
+    expect.dnodeId2 = dnodeId2;
+    expect.dnodeId3 = dnodeId3;
+  };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_REDISTRIBUTE_VGROUP_STMT);
+    ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_REDISTRIBUTE_VGROUP);
+    SRedistributeVgroupReq req = {0};
+    ASSERT_EQ(tDeserializeSRedistributeVgroupReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req),
+              TSDB_CODE_SUCCESS);
+    ASSERT_EQ(req.vgId, expect.vgId);
+    ASSERT_EQ(req.dnodeId1, expect.dnodeId1);
+    ASSERT_EQ(req.dnodeId2, expect.dnodeId2);
+    ASSERT_EQ(req.dnodeId3, expect.dnodeId3);
+  });
+
+  setRedistributeVgroupReqFunc(3, 1);
+  run("REDISTRIBUTE VGROUP 3 DNODE 1");
+
+  setRedistributeVgroupReqFunc(5, 10, 20, 30);
+  run("REDISTRIBUTE VGROUP 5 DNODE 10 DNODE 20 DNODE 30");
+}
+
 // todo reset query cache
 
 TEST_F(ParserExplainToSyncdbTest, revoke) {
diff --git a/source/libs/parser/test/parInitialATest.cpp b/source/libs/parser/test/parInitialATest.cpp
index 784586dfb2..6ac793cb0d 100644
--- a/source/libs/parser/test/parInitialATest.cpp
+++ b/source/libs/parser/test/parInitialATest.cpp
@@ -305,6 +305,19 @@ TEST_F(ParserInitialATest, alterUser) {
   run("ALTER user wxy privilege 'write'");
 }
 
+TEST_F(ParserInitialATest, balanceVgroup) {
+  useDb("root", "test");
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_BALANCE_VGROUP_STMT);
+    ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_BALANCE_VGROUP);
+    SBalanceVgroupReq req = {0};
+    ASSERT_EQ(tDeserializeSBalanceVgroupReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+  });
+
+  run("BALANCE VGROUP");
+}
+
 TEST_F(ParserInitialATest, bug001) {
   useDb("root", "test");
 
diff --git a/source/libs/qcom/src/querymsg.c b/source/libs/qcom/src/querymsg.c
index 949a58c2fa..6de1620de1 100644
--- a/source/libs/qcom/src/querymsg.c
+++ b/source/libs/qcom/src/querymsg.c
@@ -203,6 +203,24 @@ int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void*(*mallcFp)(int32_t)) {
+  if (NULL == msg || NULL == msgLen) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  STableIndexReq indexReq = {0};
+  strcpy(indexReq.tbFName, input);
+
+  int32_t bufLen = tSerializeSTableIndexReq(NULL, 0, &indexReq);
+  void   *pBuf = (*mallcFp)(bufLen);
+  tSerializeSTableIndexReq(pBuf, bufLen, &indexReq);
+
+  *msg = pBuf;
+  *msgLen = bufLen;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 
 int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) {
   SUseDbOutput *pOut = output;
@@ -459,26 +477,43 @@ int32_t queryProcessGetUserAuthRsp(void *output, char *msg, int32_t msgSize) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t queryProcessGetTbIndexRsp(void *output, char *msg, int32_t msgSize) {
+  if (NULL == output || NULL == msg || msgSize <= 0) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  STableIndexRsp out = {0};
+  if (tDeserializeSTableIndexRsp(msg, msgSize, &out) != 0) {
+    qError("tDeserializeSTableIndexRsp failed, msgSize:%d", msgSize);
+    return TSDB_CODE_INVALID_MSG;
+  }
+
+  *(void **)output = out.pIndex;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
 
 void initQueryModuleMsgHandle() {
-  queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryBuildTableMetaReqMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryBuildTableMetaReqMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_USE_DB)]     = queryBuildUseDbMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_QNODE_LIST)] = queryBuildQnodeListMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_DB_CFG)] = queryBuildGetDBCfgMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_INDEX)]  = queryBuildGetIndexMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]  = queryBuildRetrieveFuncMsg;
-  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]  = queryBuildGetUserAuthMsg;
-  
+  queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)]       = queryBuildTableMetaReqMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_TABLE_META)]       = queryBuildTableMetaReqMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_USE_DB)]           = queryBuildUseDbMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_QNODE_LIST)]       = queryBuildQnodeListMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_DB_CFG)]       = queryBuildGetDBCfgMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_INDEX)]        = queryBuildGetIndexMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]    = queryBuildRetrieveFuncMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]    = queryBuildGetUserAuthMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_TABLE_INDEX)]  = queryBuildGetTbIndexMsg;
 
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryProcessTableMetaRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryProcessTableMetaRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_USE_DB)]     = queryProcessUseDBRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_QNODE_LIST)] = queryProcessQnodeListRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_DB_CFG)] = queryProcessGetDbCfgRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_INDEX)]  = queryProcessGetIndexRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]  = queryProcessRetrieveFuncRsp;
-  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]  = queryProcessGetUserAuthRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)]      = queryProcessTableMetaRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_META)]      = queryProcessTableMetaRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_USE_DB)]          = queryProcessUseDBRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_QNODE_LIST)]      = queryProcessQnodeListRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_DB_CFG)]      = queryProcessGetDbCfgRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_INDEX)]       = queryProcessGetIndexRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]   = queryProcessRetrieveFuncRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]   = queryProcessGetUserAuthRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_TABLE_INDEX)] = queryProcessGetTbIndexRsp;
 }
 
 #pragma GCC diagnostic pop
diff --git a/source/libs/qworker/inc/qwInt.h b/source/libs/qworker/inc/qwInt.h
index 1d31c86308..2368b13dd6 100644
--- a/source/libs/qworker/inc/qwInt.h
+++ b/source/libs/qworker/inc/qwInt.h
@@ -356,7 +356,7 @@ int32_t qwOpenRef(void);
 void qwSetHbParam(int64_t refId, SQWHbParam **pParam);
 int32_t qwUpdateTimeInQueue(SQWorker *mgmt, int64_t ts, EQueueType type);
 int64_t qwGetTimeInQueue(SQWorker *mgmt, EQueueType type);
-void qwClearExpiredSch(SArray* pExpiredSch);
+void qwClearExpiredSch(SQWorker *mgmt, SArray* pExpiredSch);
 int32_t qwAcquireScheduler(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch);
 void qwFreeTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx *ctx);
 
diff --git a/source/libs/qworker/src/qwUtil.c b/source/libs/qworker/src/qwUtil.c
index 667008e68e..e5dd9e71df 100644
--- a/source/libs/qworker/src/qwUtil.c
+++ b/source/libs/qworker/src/qwUtil.c
@@ -539,8 +539,23 @@ int64_t qwGetTimeInQueue(SQWorker *mgmt, EQueueType type) {
 }
 
 
-void qwClearExpiredSch(SArray* pExpiredSch) {
+void qwClearExpiredSch(SQWorker *mgmt, SArray* pExpiredSch) {
+  int32_t num = taosArrayGetSize(pExpiredSch);
+  for (int32_t i = 0; i < num; ++i) {
+    uint64_t *sId = taosArrayGet(pExpiredSch, i);
+    SQWSchStatus *pSch = NULL;
+    if (qwAcquireScheduler(mgmt, *sId, QW_WRITE, &pSch)) {
+      continue;
+    }
 
+    if (taosHashGetSize(pSch->tasksHash) <= 0) {
+      qwDestroySchStatus(pSch);
+      taosHashRemove(mgmt->schHash, sId, sizeof(*sId));
+      qError("sch %" PRIx64 "destroyed", *sId);
+    }
+
+    qwReleaseScheduler(QW_WRITE, mgmt);
+  }
 }
 
 
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 333884f883..ae0eda5449 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -790,9 +790,10 @@ int32_t qwProcessHb(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
   }
 
   QW_ERR_JRET(qwAcquireAddScheduler(mgmt, req->sId, QW_READ, &sch));
-
   QW_ERR_JRET(qwRegisterHbBrokenLinkArg(mgmt, req->sId, &qwMsg->connInfo));
 
+  sch->hbBrokenTs = 0;
+
   QW_LOCK(QW_WRITE, &sch->hbConnLock);
 
   if (sch->hbConnInfo.handle) {
@@ -912,7 +913,7 @@ _return:
   }
 
   if (taosArrayGetSize(pExpiredSch) > 0) {
-    qwClearExpiredSch(pExpiredSch);
+    qwClearExpiredSch(mgmt, pExpiredSch);
   }
 
   taosMemoryFreeClear(rspList);
diff --git a/source/libs/scheduler/inc/schedulerInt.h b/source/libs/scheduler/inc/schedulerInt.h
index d961780ae5..9e302e569a 100644
--- a/source/libs/scheduler/inc/schedulerInt.h
+++ b/source/libs/scheduler/inc/schedulerInt.h
@@ -207,6 +207,7 @@ typedef struct SSchJob {
   SArray          *dataSrcTasks; // SArray<SQueryTask*>
   int32_t          levelIdx;
   SEpSet           dataSrcEps;
+  SHashObj        *taskList;
   SHashObj        *execTasks; // executing tasks, key:taskid, value:SQueryTask*
   SHashObj        *succTasks; // succeed tasks, key:taskid, value:SQueryTask*
   SHashObj        *failTasks; // failed tasks, key:taskid, value:SQueryTask*
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index 09f2efc7e2..d799169ee4 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -63,6 +63,13 @@ int32_t schInitJob(SSchJob **pSchJob, SQueryPlan *pDag, void *pTrans, SArray *pN
   if (pNodeList != NULL) {
     pJob->nodeList = taosArrayDup(pNodeList);
   }
+  
+  pJob->taskList =
+      taosHashInit(pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
+  if (NULL == pJob->taskList) {
+    SCH_JOB_ELOG("taosHashInit %d taskList failed", pDag->numOfSubplans);
+    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
 
   SCH_ERR_JRET(schValidateAndBuildJob(pDag, pJob));
 
@@ -486,23 +493,26 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
       SCH_SET_JOB_TYPE(pJob, plan->subplanType);
 
       SSchTask  task = {0};
-      SSchTask *pTask = &task;
-
       SCH_ERR_JRET(schInitTask(pJob, &task, plan, pLevel));
 
-      void *p = taosArrayPush(pLevel->subTasks, &task);
-      if (NULL == p) {
+      SSchTask *pTask = taosArrayPush(pLevel->subTasks, &task);
+      if (NULL == pTask) {
         SCH_TASK_ELOG("taosArrayPush task to level failed, level:%d, taskIdx:%d", pLevel->level, n);
         SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
       }
 
-      SCH_ERR_JRET(schRecordQueryDataSrc(pJob, p));
+      SCH_ERR_JRET(schRecordQueryDataSrc(pJob, pTask));
 
-      if (0 != taosHashPut(planToTask, &plan, POINTER_BYTES, &p, POINTER_BYTES)) {
+      if (0 != taosHashPut(planToTask, &plan, POINTER_BYTES, &pTask, POINTER_BYTES)) {
         SCH_TASK_ELOG("taosHashPut to planToTaks failed, taskIdx:%d", n);
         SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
       }
 
+      if (0 != taosHashPut(pJob->taskList, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES)) {
+        SCH_TASK_ELOG("taosHashPut to taskList failed, taskIdx:%d", n);
+        SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+      }
+
       ++pJob->taskNum;
     }
 
@@ -1276,14 +1286,10 @@ int32_t schGetTaskFromList(SHashObj *pTaskList, uint64_t taskId, SSchTask **pTas
 }
 
 int32_t schGetTaskInJob(SSchJob *pJob, uint64_t taskId, SSchTask **pTask) {
-  schGetTaskFromList(pJob->execTasks, taskId, pTask);
+  schGetTaskFromList(pJob->taskList, taskId, pTask);
   if (NULL == *pTask) {
-    schGetTaskFromList(pJob->succTasks, taskId, pTask);
-
-    if (NULL == *pTask) {
-      SCH_JOB_ELOG("task not found in execList & succList, taskId:%" PRIx64, taskId);
-      SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
-    }
+    SCH_JOB_ELOG("task not found in job task list, taskId:%" PRIx64, taskId);
+    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1445,7 +1451,8 @@ void schFreeJobImpl(void *job) {
   taosHashCleanup(pJob->execTasks);
   taosHashCleanup(pJob->failTasks);
   taosHashCleanup(pJob->succTasks);
-
+  taosHashCleanup(pJob->taskList);
+  
   taosArrayDestroy(pJob->levels);
   taosArrayDestroy(pJob->nodeList);
   taosArrayDestroy(pJob->dataSrcTasks);
diff --git a/source/libs/stream/src/stream.c b/source/libs/stream/src/stream.c
index 91ede155bb..3298ecfc3e 100644
--- a/source/libs/stream/src/stream.c
+++ b/source/libs/stream/src/stream.c
@@ -26,7 +26,7 @@ int32_t streamTriggerByWrite(SStreamTask* pTask, int32_t vgId, SMsgCb* pMsgCb) {
     pRunReq->streamId = pTask->streamId;
     pRunReq->taskId = pTask->taskId;
     SRpcMsg msg = {
-        .msgType = TDMT_VND_TASK_RUN,
+        .msgType = TDMT_STREAM_TASK_RUN,
         .pCont = pRunReq,
         .contLen = sizeof(SStreamTaskRunReq),
     };
diff --git a/source/libs/stream/src/streamMsg.c b/source/libs/stream/src/streamMsg.c
index 06c12ec343..a52afe93b7 100644
--- a/source/libs/stream/src/streamMsg.c
+++ b/source/libs/stream/src/streamMsg.c
@@ -190,9 +190,9 @@ int32_t streamDispatch(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDataBlock* dat
     }
 
     int32_t qType;
-    if (pTask->dispatchMsgType == TDMT_VND_TASK_DISPATCH || pTask->dispatchMsgType == TDMT_SND_TASK_DISPATCH) {
+    if (pTask->dispatchMsgType == TDMT_STREAM_TASK_DISPATCH) {
       qType = FETCH_QUEUE;
-    } else if (pTask->dispatchMsgType == TDMT_VND_TASK_DISPATCH_WRITE) {
+    } else if (pTask->dispatchMsgType == TDMT_VND_STREAM_DISPATCH_WRITE) {
       qType = WRITE_QUEUE;
     } else {
       ASSERT(0);
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index 0357ce7b4b..71c348f810 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -451,9 +451,89 @@ TAOS_DEFINE_ERROR(TSDB_CODE_SCH_TIMEOUT_ERROR,            "Task timeout")
 TAOS_DEFINE_ERROR(TSDB_CODE_QW_MSG_ERROR,                 "Invalid msg order")
 
 // parser
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TABLE_NOT_EXIST,          "Table does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PERMISSION_DENIED,        "Permission denied")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR,           "Parser internal error")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PERMISSION_DENIED,         "Permission denied")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR,            "Parser internal error")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SYNTAX_ERROR,              "syntax error near")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INCOMPLETE_SQL,            "Incomplete SQL statement")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COLUMN,            "Invalid column name")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TABLE_NOT_EXIST,           "Table does not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_AMBIGUOUS_COLUMN,          "Column ambiguously defined")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_WRONG_VALUE_TYPE,          "Invalid value type")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION,  "There mustn't be aggregation")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT,    "ORDER BY item must be the number of a SELECT-list expression")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_GROUPBY_LACK_EXPRESSION,   "Not a GROUP BY expression")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_SELECTED_EXPRESSION,   "Not SELECTed expression")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_SINGLE_GROUP,          "Not a single-group group function")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TAGS_NOT_MATCHED,          "Tags number not matched")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TAG_NAME,          "Invalid tag name")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG,   "Name or password too long")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PASSWD_EMPTY,              "Password can not be empty")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_PORT,              "Port should be an integer that is less than 65535 and greater than 0")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ENDPOINT,          "Endpoint should be in the format of 'fqdn:port'")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_EXPRIE_STATEMENT,          "This statement is no longer supported")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL,     "Interval too small")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_DB_NOT_SPECIFIED,          "Database not specified")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME,   "Invalid identifier name")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_CORRESPONDING_STABLE_ERR,  "Corresponding super table not in this db")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_RANGE_OPTION,      "Invalid option")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STR_OPTION,        "Invalid option")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ENUM_OPTION,       "Invalid option")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_NUM,          "Invalid number of keep options")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_ORDER,        "Invalid keep value, should be keep0 <= keep1 <= keep2")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_VALUE,        "Invalid option keep")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COMMENT_OPTION,    "Invalid option comment")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_F_RANGE_OPTION,    "Invalid option")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ROLLUP_OPTION,     "Invalid option rollup: only one function is allowed")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION, "Invalid option retentions")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST,    "GROUP BY and WINDOW-clause can't be used together")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_OPTION_UNIT,       "Invalid option unit: only m, h, d allowed")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_UNIT,         "Invalid option keep unit: only m, h, d allowed")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_AGG_FUNC_NESTING,          "Aggregate functions do not support nesting")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE,    "Only support STATE_WINDOW on integer/bool/varchar column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STATE_WIN_COL,     "Not support STATE_WINDOW on tag column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STATE_WIN_TABLE,   "STATE_WINDOW not support for super table query")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SESSION_GAP,         "SESSION gap should be fixed time window, and greater than 0")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SESSION_COL,         "Only support SESSION on primary timestamp column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_OFFSET_NEGATIVE,     "Interval offset cannot be negative")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_OFFSET_UNIT,         "Cannot use 'year' as offset when interval is 'month'")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_OFFSET_TOO_BIG,      "Interval offset should be shorter than interval")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SLIDING_UNIT,        "Does not support sliding when interval is natural month/year")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SLIDING_TOO_BIG,     "sliding value no larger than the interval value")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SLIDING_TOO_SMALL,   "sliding value can not less than 1% of interval value")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_ONLY_ONE_JSON_TAG,         "Only one tag if there is a json tag")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INCORRECT_NUM_OF_COL,      "Query block has incorrect number of result columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INCORRECT_TIMESTAMP_VAL,   "Incorrect TIMESTAMP value")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DAYS_VALUE,        "Invalid days value, should be keep2 >= keep1 >= keep0 >= days")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_OFFSET_LESS_ZERO,          "soffset/offset can not be less than 0")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SLIMIT_LEAK_PARTITION_BY,  "slimit/soffset only available for PARTITION BY query")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TOPIC_QUERY,        "Invalid topic query")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DROP_STABLE,        "Cannot drop super table in batch")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_FILL_TIME_RANGE,    "Start(end) time of query range required or time range too large")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_DUPLICATED_COLUMN,          "Duplicated column names")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TAGS_LENGTH,        "Tags length exceeds max length")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ROW_LENGTH,         "Row length exceeds max length")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COLUMNS_NUM,        "Illegal number of columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TOO_MANY_COLUMNS,           "Too many columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_FIRST_COLUMN,       "First column must be timestamp")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN,     "Invalid binary/nchar column length")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TAGS_NUM,           "Invalid number of tag columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_INTERNAL_PK,        "Invalid _c0 or _rowts expression")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TIMELINE_FUNC,      "Invalid timeline function")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_PASSWD,             "Invalid password")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ALTER_TABLE,        "Invalid alter table statement")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_CANNOT_DROP_PRIMARY_KEY,    "Primary timestamp column cannot be dropped")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_MODIFY_COL,         "Only binary/nchar column length could be modified")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TBNAME,             "Invalid tbname pseudo column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_FUNCTION_NAME,      "Invalid function name")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_COMMENT_TOO_LONG,           "Comment too long")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_FUNC,           "Some functions are allowed only in the SELECT list of a query. "
+                                                            "And, cannot be mixed with other non scalar functions or columns.")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY,      "Window query not supported, since the result of subquery not include valid timestamp column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DROP_COL,           "No columns can be dropped")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COL_JSON,           "Only tag can be json type")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_VALUE_TOO_LONG,             "Value too long for column/tag")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DELETE_WHERE,       "The DELETE statement must have a definite time window range")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG,    "The REDISTRIBUTE VGROUP statement only support 1 to 3 dnodes")
 
 //planner
 TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_INTERNAL_ERROR,          "Planner internal error")
diff --git a/tests/pytest/test.py b/tests/pytest/test.py
index 30ab6ae3cc..1b185ef189 100644
--- a/tests/pytest/test.py
+++ b/tests/pytest/test.py
@@ -131,7 +131,7 @@ if __name__ == "__main__":
             is_test_framework = 0
             key_word = 'tdCases.addWindows'
             try:
-                if key_word in open(fileName).read():
+                if key_word in open(fileName, encoding='UTF-8').read():
                     is_test_framework = 1
             except:
                 pass
diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index 63b841cfc5..c2aed6555d 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -416,7 +416,7 @@ class TDDnode:
                     psCmd, shell=True).decode("utf-8")
             if not platform.system().lower() == 'windows':
                 for port in range(6030, 6041):
-                    fuserCmd = "fuser -k -n tcp %d" % port
+                    fuserCmd = "fuser -k -n tcp %d > /dev/null" % port
                     os.system(fuserCmd)
             if self.valgrind:
                 time.sleep(2)
diff --git a/tests/system-test/2-query/between.py b/tests/system-test/2-query/between.py
index 44750abd46..7e2ac1c8b9 100644
--- a/tests/system-test/2-query/between.py
+++ b/tests/system-test/2-query/between.py
@@ -143,7 +143,7 @@ class TDTestCase:
         tdSql.checkRows(9)
         tdSql.query("select * from t1 where c5 between 136 and 127")
         tdSql.checkRows(0)
-        tdSql.query("select * from t1 where c5 between '~' and 'ˆ'")
+        tdSql.query("select * from t1 where c5 between '~' and '^'")
         tdSql.checkRows(0)
         tdSql.query("select * from t1 where c5 not between 1 and 2")
         # tdSql.checkRows(0)
diff --git a/tests/system-test/2-query/cast.py b/tests/system-test/2-query/cast.py
index e07ab95f45..387170991f 100644
--- a/tests/system-test/2-query/cast.py
+++ b/tests/system-test/2-query/cast.py
@@ -565,7 +565,7 @@ class TDTestCase:
             if data_ct4_c10[i] is None:
                 tdSql.checkData( i, 0, None )
             else:
-                time2str = str(int(datetime.datetime.timestamp(data_ct4_c10[i])*1000))
+                time2str = str(int((data_ct4_c10[i]-datetime.datetime.fromtimestamp(0)).total_seconds()*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)):
@@ -574,7 +574,7 @@ class TDTestCase:
             elif i == 10:
                 continue
             else:
-                time2str = str(int(datetime.datetime.timestamp(data_t1_c10[i])*1000))
+                time2str = str(int((data_t1_c10[i]-datetime.datetime.fromtimestamp(0)).total_seconds()*1000))
                 tdSql.checkData( i, 0, time2str )
 
         tdLog.printNoPrefix("==========step38: cast timestamp to binary, expect no changes ")
@@ -583,7 +583,7 @@ class TDTestCase:
             if data_ct4_c10[i] is None:
                 tdSql.checkData( i, 0, None )
             else:
-                time2str = str(int(datetime.datetime.timestamp(data_ct4_c10[i])*1000))
+                time2str = str(int((data_ct4_c10[i]-datetime.datetime.fromtimestamp(0)).total_seconds()*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)):
@@ -592,7 +592,7 @@ class TDTestCase:
             elif i == 10:
                 continue
             else:
-                time2str = str(int(datetime.datetime.timestamp(data_t1_c10[i])*1000))
+                time2str = str(int((data_t1_c10[i]-datetime.datetime.fromtimestamp(0)).total_seconds()*1000))
                 tdSql.checkData( i, 0, time2str )
 
         tdLog.printNoPrefix("==========step39: cast constant operation to bigint, expect change to int ")
diff --git a/tests/system-test/test-all.bat b/tests/system-test/test-all.bat
index baafbc9e08..9c2e58ea3f 100644
--- a/tests/system-test/test-all.bat
+++ b/tests/system-test/test-all.bat
@@ -13,6 +13,9 @@ echo Linux Taosd Test
 for /F "usebackq tokens=*" %%i in (fulltest.bat) do (
     for /f "tokens=1* delims= " %%a in ("%%i") do if not "%%a" == "@REM" (
         echo Processing %%i
+        call :GetTimeSeconds %time%
+        set time1=!_timeTemp!
+        echo Start at %time%
         set /a a+=1
         call %%i ARG1 -m %1 > result_!a!.txt 2>error_!a!.txt
         if errorlevel 1 ( call :colorEcho 0c "failed" &echo. && echo result: && cat result_!a!.txt && echo error: && cat error_!a!.txt && exit 8 ) else ( call :colorEcho 0a "Success" &echo. ) 
@@ -21,7 +24,33 @@ for /F "usebackq tokens=*" %%i in (fulltest.bat) do (
 exit
 
 :colorEcho
+call :GetTimeSeconds %time%
+set time2=%_timeTemp%
+set /a interTime=%time2% - %time1%
+echo End at %time% , cast %interTime%s
 echo off
 <nul set /p ".=%DEL%" > "%~2"
 findstr /v /a:%1 /R "^$" "%~2" nul
-del "%~2" > nul 2>&1i
\ No newline at end of file
+del "%~2" > nul 2>&1i
+goto :eof
+
+:GetTimeSeconds
+set tt=%1
+set tt=%tt:.= %
+set tt=%tt::= %
+set index=1
+for %%a in (%tt%) do (
+    if !index! EQU 1 (
+        set hh=%%a
+    )^
+    else if  !index! EQU 2 (
+        set mm=%%a
+ 
+    )^
+    else if  !index! EQU 3 (
+        set ss=%%a
+    )
+   set /a index=index+1
+)
+set /a _timeTemp=(%hh%*60+%mm%)*60+%ss%
+goto :eof
\ No newline at end of file
diff --git a/tests/system-test/test.py b/tests/system-test/test.py
index d9ae792901..8350f6752f 100644
--- a/tests/system-test/test.py
+++ b/tests/system-test/test.py
@@ -168,7 +168,7 @@ if __name__ == "__main__":
         key_word = 'tdCases.addWindows'
         is_test_framework = 0
         try:
-            if key_word in open(fileName).read():
+            if key_word in open(fileName, encoding='UTF-8').read():
                 is_test_framework = 1
         except:
             pass