diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h
index 1bc2d23df9..a5651f96f4 100644
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@@ -205,65 +205,65 @@
 #define TK_SPLIT          187
 #define TK_SYNCDB         188
 #define TK_DELETE         189
-#define TK_NULL           190
-#define TK_NK_QUESTION    191
-#define TK_NK_ARROW       192
-#define TK_ROWTS          193
-#define TK_TBNAME         194
-#define TK_QSTARTTS       195
-#define TK_QENDTS         196
-#define TK_WSTARTTS       197
-#define TK_WENDTS         198
-#define TK_WDURATION      199
-#define TK_CAST           200
-#define TK_NOW            201
-#define TK_TODAY          202
-#define TK_TIMEZONE       203
-#define TK_CLIENT_VERSION 204
-#define TK_SERVER_VERSION 205
-#define TK_SERVER_STATUS  206
-#define TK_CURRENT_USER   207
-#define TK_COUNT          208
-#define TK_LAST_ROW       209
-#define TK_BETWEEN        210
-#define TK_IS             211
-#define TK_NK_LT          212
-#define TK_NK_GT          213
-#define TK_NK_LE          214
-#define TK_NK_GE          215
-#define TK_NK_NE          216
-#define TK_MATCH          217
-#define TK_NMATCH         218
-#define TK_CONTAINS       219
-#define TK_JOIN           220
-#define TK_INNER          221
-#define TK_SELECT         222
-#define TK_DISTINCT       223
-#define TK_WHERE          224
-#define TK_PARTITION      225
-#define TK_BY             226
-#define TK_SESSION        227
-#define TK_STATE_WINDOW   228
-#define TK_SLIDING        229
-#define TK_FILL           230
-#define TK_VALUE          231
-#define TK_NONE           232
-#define TK_PREV           233
-#define TK_LINEAR         234
-#define TK_NEXT           235
-#define TK_HAVING         236
-#define TK_RANGE          237
-#define TK_EVERY          238
-#define TK_ORDER          239
-#define TK_SLIMIT         240
-#define TK_SOFFSET        241
-#define TK_LIMIT          242
-#define TK_OFFSET         243
-#define TK_ASC            244
-#define TK_NULLS          245
-#define TK_ID             246
-#define TK_NK_BITNOT      247
-#define TK_INSERT         248
+#define TK_INSERT         190
+#define TK_NULL           191
+#define TK_NK_QUESTION    192
+#define TK_NK_ARROW       193
+#define TK_ROWTS          194
+#define TK_TBNAME         195
+#define TK_QSTARTTS       196
+#define TK_QENDTS         197
+#define TK_WSTARTTS       198
+#define TK_WENDTS         199
+#define TK_WDURATION      200
+#define TK_CAST           201
+#define TK_NOW            202
+#define TK_TODAY          203
+#define TK_TIMEZONE       204
+#define TK_CLIENT_VERSION 205
+#define TK_SERVER_VERSION 206
+#define TK_SERVER_STATUS  207
+#define TK_CURRENT_USER   208
+#define TK_COUNT          209
+#define TK_LAST_ROW       210
+#define TK_BETWEEN        211
+#define TK_IS             212
+#define TK_NK_LT          213
+#define TK_NK_GT          214
+#define TK_NK_LE          215
+#define TK_NK_GE          216
+#define TK_NK_NE          217
+#define TK_MATCH          218
+#define TK_NMATCH         219
+#define TK_CONTAINS       220
+#define TK_JOIN           221
+#define TK_INNER          222
+#define TK_SELECT         223
+#define TK_DISTINCT       224
+#define TK_WHERE          225
+#define TK_PARTITION      226
+#define TK_BY             227
+#define TK_SESSION        228
+#define TK_STATE_WINDOW   229
+#define TK_SLIDING        230
+#define TK_FILL           231
+#define TK_VALUE          232
+#define TK_NONE           233
+#define TK_PREV           234
+#define TK_LINEAR         235
+#define TK_NEXT           236
+#define TK_HAVING         237
+#define TK_RANGE          238
+#define TK_EVERY          239
+#define TK_ORDER          240
+#define TK_SLIMIT         241
+#define TK_SOFFSET        242
+#define TK_LIMIT          243
+#define TK_OFFSET         244
+#define TK_ASC            245
+#define TK_NULLS          246
+#define TK_ID             247
+#define TK_NK_BITNOT      248
 #define TK_VALUES         249
 #define TK_IMPORT         250
 #define TK_NK_SEMI        251
diff --git a/include/libs/index/index.h b/include/libs/index/index.h
index 9e71c941d3..5a3c4cfee7 100644
--- a/include/libs/index/index.h
+++ b/include/libs/index/index.h
@@ -208,7 +208,7 @@ int32_t doFilterTag(const SNode* pFilterNode, SIndexMetaArg* metaArg, SArray* re
  * destory index env
  *
  */
-void indexCleanUp();
+void indexCleanup();
 
 #ifdef __cplusplus
 }
diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index f1891c3764..30bcf22989 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -195,6 +195,7 @@ typedef enum ENodeType {
   QUERY_NODE_KILL_QUERY_STMT,
   QUERY_NODE_KILL_TRANSACTION_STMT,
   QUERY_NODE_DELETE_STMT,
+  QUERY_NODE_INSERT_STMT,
   QUERY_NODE_QUERY,
 
   // logic plan node
@@ -248,6 +249,7 @@ typedef enum ENodeType {
   QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
   QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
   QUERY_NODE_PHYSICAL_PLAN_INSERT,
+  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
   QUERY_NODE_PHYSICAL_PLAN_DELETE,
   QUERY_NODE_PHYSICAL_SUBPLAN,
   QUERY_NODE_PHYSICAL_PLAN
diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index debfce5f2d..e3d26edf30 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -131,6 +131,7 @@ typedef struct SVnodeModifyLogicNode {
   int8_t           tableType;  // table type
   char             tableFName[TSDB_TABLE_FNAME_LEN];
   STimeWindow      deleteTimeRange;
+  SVgroupsInfo*    pVgroupList;
 } SVnodeModifyLogicNode;
 
 typedef struct SExchangeLogicNode {
@@ -456,6 +457,15 @@ typedef struct SDataInserterNode {
   char*         pData;
 } SDataInserterNode;
 
+typedef struct SQueryInserterNode {
+  SDataSinkNode sink;
+  uint64_t      tableId;
+  int8_t        tableType;  // table type
+  char          tableFName[TSDB_TABLE_FNAME_LEN];
+  int32_t       vgId;
+  SEpSet        epSet;
+} SQueryInserterNode;
+
 typedef struct SDataDeleterNode {
   SDataSinkNode sink;
   uint64_t      tableId;
diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index dd337bcee0..b9a0b90a9a 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -302,6 +302,14 @@ typedef struct SDeleteStmt {
   bool        deleteZeroRows;
 } SDeleteStmt;
 
+typedef struct SInsertStmt {
+  ENodeType  type;  // QUERY_NODE_INSERT_STMT
+  SNode*     pTable;
+  SNodeList* pCols;
+  SNode*     pQuery;
+  uint8_t    precision;
+} SInsertStmt;
+
 typedef enum {
   PAYLOAD_TYPE_KV = 0,
   PAYLOAD_TYPE_RAW = 1,
diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h
index 6c2a9bb374..c3007306ae 100644
--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@@ -56,7 +56,7 @@ typedef struct SParseContext {
 } SParseContext;
 
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery);
-bool    qIsInsertSql(const char* pStr, size_t length);
+bool    qIsInsertValuesSql(const char* pStr, size_t length);
 
 // for async mode
 int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq);
diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h
index 8edb50baed..a93cf1f9b8 100644
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@@ -29,12 +29,13 @@ extern "C" {
 
 typedef enum {
   JOB_TASK_STATUS_NULL = 0,
-  JOB_TASK_STATUS_NOT_START = 1,
-  JOB_TASK_STATUS_EXECUTING,
-  JOB_TASK_STATUS_PARTIAL_SUCCEED,
-  JOB_TASK_STATUS_SUCCEED,
-  JOB_TASK_STATUS_FAILED,
-  JOB_TASK_STATUS_DROPPING,
+  JOB_TASK_STATUS_INIT,
+  JOB_TASK_STATUS_EXEC,
+  JOB_TASK_STATUS_PART_SUCC,
+  JOB_TASK_STATUS_SUCC,
+  JOB_TASK_STATUS_FAIL,
+  JOB_TASK_STATUS_DROP,
+  JOB_TASK_STATUS_MAX,
 } EJobTaskType;
 
 typedef enum {
@@ -59,10 +60,6 @@ typedef struct STableComInfo {
   int32_t  rowSize;       // row size of the schema
 } STableComInfo;
 
-typedef struct SQueryExecRes {
-  int32_t msgType;
-  void*   res;
-} SQueryExecRes;
 
 typedef struct SIndexMeta {
 #if defined(WINDOWS) || defined(_TD_DARWIN_64)
@@ -71,6 +68,13 @@ typedef struct SIndexMeta {
 
 } SIndexMeta;
 
+typedef struct SExecResult {
+  int32_t         code;
+  uint64_t        numOfRows;
+  int32_t         msgType;
+  void*           res;
+} SExecResult;
+
 typedef struct STbVerInfo {
   char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
@@ -210,7 +214,7 @@ char*   jobTaskStatusStr(int32_t status);
 
 SSchema createSchema(int8_t type, int32_t bytes, col_id_t colId, const char* name);
 
-void    destroyQueryExecRes(SQueryExecRes* pRes);
+void    destroyQueryExecRes(SExecResult* pRes);
 int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len);
 char*   parseTagDatatoJson(void* p);
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
diff --git a/include/libs/scheduler/scheduler.h b/include/libs/scheduler/scheduler.h
index 1c73b2c2c8..70ac7a6304 100644
--- a/include/libs/scheduler/scheduler.h
+++ b/include/libs/scheduler/scheduler.h
@@ -53,12 +53,6 @@ typedef struct SQueryProfileSummary {
   uint64_t resultSize;   // generated result size in Kb.
 } SQueryProfileSummary;
 
-typedef struct SQueryResult {
-  int32_t         code;
-  uint64_t        numOfRows;
-  SQueryExecRes   res;
-} SQueryResult;
-
 typedef struct STaskInfo {
   SQueryNodeAddr addr;
   SSubQueryMsg  *msg;
@@ -69,50 +63,34 @@ typedef struct SSchdFetchParam {
   int32_t* code;
 } SSchdFetchParam;
 
-typedef void (*schedulerExecFp)(SQueryResult* pResult, void* param, int32_t code);
+typedef void (*schedulerExecFp)(SExecResult* pResult, void* param, int32_t code);
 typedef void (*schedulerFetchFp)(void* pResult, void* param, int32_t code);
 typedef bool (*schedulerChkKillFp)(void* param);
 
 typedef struct SSchedulerReq {
+  bool                  syncReq;
   SRequestConnInfo     *pConn;
   SArray               *pNodeList;
   SQueryPlan           *pDag;
   const char           *sql;
   int64_t               startTs;
   schedulerExecFp       execFp;
-  void*                 execParam;
+  schedulerFetchFp      fetchFp;
+  void*                 cbParam;
   schedulerChkKillFp    chkKillFp;
   void*                 chkKillParam;
+  SExecResult*          pExecRes;
+  void**                pFetchRes;
 } SSchedulerReq;
 
 
 int32_t schedulerInit(SSchedulerCfg *cfg);
 
-/**
- * Process the query job, generated according to the query physical plan.
- * This is a synchronized API, and is also thread-safety.
- * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
- * @return
- */
-int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJob, SQueryResult *pRes);
+int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJob);
 
-/**
- * Process the query job, generated according to the query physical plan.
- * This is a asynchronized API, and is also thread-safety.
- * @param pNodeList  Qnode/Vnode address list, element is SQueryNodeAddr
- * @return
- */
-  int32_t schedulerAsyncExecJob(SSchedulerReq *pReq, int64_t *pJob);
+int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq);
 
-/**
- * Fetch query result from the remote query executor
- * @param pJob
- * @param data
- * @return
- */
-int32_t schedulerFetchRows(int64_t job, void **data);
-
-void schedulerAsyncFetchRows(int64_t job, schedulerFetchFp fp, void* param);
+void schedulerFetchRowsA(int64_t job, schedulerFetchFp fp, void* param);
 
 int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub);
 
@@ -134,7 +112,7 @@ void schedulerFreeJob(int64_t* job, int32_t errCode);
 
 void schedulerDestroy(void);
 
-void schdExecCallback(SQueryResult* pResult, void* param, int32_t code);
+void schdExecCallback(SExecResult* pResult, void* param, int32_t code);
 
 #ifdef __cplusplus
 }
diff --git a/include/libs/sync/sync.h b/include/libs/sync/sync.h
index a93b359ef3..5c539f0ef3 100644
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@@ -26,7 +26,7 @@ extern "C" {
 
 extern bool gRaftDetailLog;
 
-#define SYNC_MAX_BATCH_SIZE 100
+#define SYNC_MAX_BATCH_SIZE 500
 #define SYNC_INDEX_BEGIN 0
 #define SYNC_INDEX_INVALID -1
 #define SYNC_TERM_INVALID 0xFFFFFFFFFFFFFFFF
diff --git a/include/os/osMemory.h b/include/os/osMemory.h
index ba69a32941..88dfe02074 100644
--- a/include/os/osMemory.h
+++ b/include/os/osMemory.h
@@ -32,7 +32,7 @@ extern "C" {
 void *taosMemoryMalloc(int32_t size);
 void *taosMemoryCalloc(int32_t num, int32_t size);
 void *taosMemoryRealloc(void *ptr, int32_t size);
-void *taosMemoryStrDup(void *ptr);
+void *taosMemoryStrDup(const char *ptr);
 void taosMemoryFree(void *ptr);
 int32_t taosMemorySize(void *ptr);
 void taosPrintBackTrace();
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 0ad7f8f7a7..41d5910625 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -390,10 +390,10 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_TASK_MSG_ERROR            TAOS_DEF_ERROR_CODE(0, 0x0719)
 #define TSDB_CODE_QRY_JOB_FREED                 TAOS_DEF_ERROR_CODE(0, 0x071A)
 #define TSDB_CODE_QRY_TASK_STATUS_ERROR         TAOS_DEF_ERROR_CODE(0, 0x071B)
-//json
 #define TSDB_CODE_QRY_JSON_IN_ERROR             TAOS_DEF_ERROR_CODE(0, 0x071C)
 #define TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR    TAOS_DEF_ERROR_CODE(0, 0x071D)
 #define TSDB_CODE_QRY_JSON_IN_GROUP_ERROR       TAOS_DEF_ERROR_CODE(0, 0x071E)
+#define TSDB_CODE_QRY_JOB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x071F)
 
 // grant
 #define TSDB_CODE_GRANT_EXPIRED                 TAOS_DEF_ERROR_CODE(0, 0x0800)
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index b930f57d92..9380b73d2d 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -156,7 +156,7 @@ typedef struct SResultColumn {
 } SResultColumn;
 
 typedef struct SReqResultInfo {
-  SQueryExecRes  execRes;
+  SExecResult    execRes;
   const char*    pRspMsg;
   const char*    pData;
   TAOS_FIELD*    fields;      // todo, column names are not needed.
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 0fe4274091..671f04089c 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -627,22 +627,26 @@ _return:
 int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList) {
   void* pTransporter = pRequest->pTscObj->pAppInfo->pTransporter;
 
-  SQueryResult     res = {0};
+  SExecResult     res = {0};
   SRequestConnInfo conn = {.pTrans = pRequest->pTscObj->pAppInfo->pTransporter,
                            .requestId = pRequest->requestId,
                            .requestObjRefId = pRequest->self};
-  SSchedulerReq    req = {.pConn = &conn,
-                       .pNodeList = pNodeList,
-                       .pDag = pDag,
-                       .sql = pRequest->sqlstr,
-                       .startTs = pRequest->metric.start,
-                       .execFp = NULL,
-                       .execParam = NULL,
-                       .chkKillFp = chkRequestKilled,
-                       .chkKillParam = (void*)pRequest->self};
+  SSchedulerReq    req = {
+    .syncReq = true,
+    .pConn = &conn,
+    .pNodeList = pNodeList,
+    .pDag = pDag,
+    .sql = pRequest->sqlstr,
+    .startTs = pRequest->metric.start,
+    .execFp = NULL,
+    .cbParam = NULL,
+    .chkKillFp = chkRequestKilled,
+    .chkKillParam = (void*)pRequest->self,
+    .pExecRes = &res,
+  };
 
-  int32_t code = schedulerExecJob(&req, &pRequest->body.queryJob, &res);
-  pRequest->body.resInfo.execRes = res.res;
+  int32_t code = schedulerExecJob(&req, &pRequest->body.queryJob);
+  memcpy(&pRequest->body.resInfo.execRes, &res, sizeof(res));
 
   if (code != TSDB_CODE_SUCCESS) {
     schedulerFreeJob(&pRequest->body.queryJob, 0);
@@ -753,7 +757,7 @@ int32_t handleQueryExecRsp(SRequestObj* pRequest) {
   }
 
   SEpSet         epset = getEpSet_s(&pAppInfo->mgmtEp);
-  SQueryExecRes* pRes = &pRequest->body.resInfo.execRes;
+  SExecResult* pRes = &pRequest->body.resInfo.execRes;
 
   switch (pRes->msgType) {
     case TDMT_VND_ALTER_TABLE:
@@ -779,10 +783,10 @@ int32_t handleQueryExecRsp(SRequestObj* pRequest) {
   return code;
 }
 
-void schedulerExecCb(SQueryResult* pResult, void* param, int32_t code) {
+void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
   SRequestObj* pRequest = (SRequestObj*)param;
   pRequest->code = code;
-  pRequest->body.resInfo.execRes = pResult->res;
+  memcpy(&pRequest->body.resInfo.execRes, pResult, sizeof(*pResult));
 
   if (TDMT_VND_SUBMIT == pRequest->type || TDMT_VND_DELETE == pRequest->type ||
       TDMT_VND_CREATE_TABLE == pRequest->type) {
@@ -939,16 +943,20 @@ void launchAsyncQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaData* pResultM
 
         SRequestConnInfo conn = {
             .pTrans = pAppInfo->pTransporter, .requestId = pRequest->requestId, .requestObjRefId = pRequest->self};
-        SSchedulerReq req = {.pConn = &conn,
-                             .pNodeList = pNodeList,
-                             .pDag = pDag,
-                             .sql = pRequest->sqlstr,
-                             .startTs = pRequest->metric.start,
-                             .execFp = schedulerExecCb,
-                             .execParam = pRequest,
-                             .chkKillFp = chkRequestKilled,
-                             .chkKillParam = (void*)pRequest->self};
-        code = schedulerAsyncExecJob(&req, &pRequest->body.queryJob);
+        SSchedulerReq req = {
+          .syncReq = false,
+          .pConn = &conn,
+          .pNodeList = pNodeList,
+          .pDag = pDag,
+          .sql = pRequest->sqlstr,
+          .startTs = pRequest->metric.start,
+          .execFp = schedulerExecCb,
+          .cbParam = pRequest,
+          .chkKillFp = chkRequestKilled,
+          .chkKillParam = (void*)pRequest->self,
+          .pExecRes = NULL,
+        };
+        code = schedulerExecJob(&req, &pRequest->body.queryJob);
         taosArrayDestroy(pNodeList);
       } else {
         tscDebug("0x%" PRIx64 " plan not executed, code:%s 0x%" PRIx64, pRequest->self, tstrerror(code),
@@ -1387,7 +1395,11 @@ void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4)
     }
 
     SReqResultInfo* pResInfo = &pRequest->body.resInfo;
-    pRequest->code = schedulerFetchRows(pRequest->body.queryJob, (void**)&pResInfo->pData);
+    SSchedulerReq req = {
+      .syncReq = true,
+      .pFetchRes = (void**)&pResInfo->pData,
+    };
+    pRequest->code = schedulerFetchRows(pRequest->body.queryJob, &req);
     if (pRequest->code != TSDB_CODE_SUCCESS) {
       pResultInfo->numOfRows = 0;
       return NULL;
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index a30d60a589..44b8412064 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -858,7 +858,12 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
     }
   }
 
-  schedulerAsyncFetchRows(pRequest->body.queryJob, fetchCallback, pRequest);
+  SSchedulerReq req = {
+    .syncReq = false,
+    .fetchFp = fetchCallback,
+    .cbParam = pRequest,
+  };
+  schedulerFetchRows(pRequest->body.queryJob, &req);
 }
 
 void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
diff --git a/source/client/src/clientMsgHandler.c b/source/client/src/clientMsgHandler.c
index 761eebee42..dcccbb17c9 100644
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@@ -266,7 +266,7 @@ int32_t processAlterStbRsp(void* param, SDataBuf* pMsg, int32_t code) {
   }
 
   if (pRequest->body.queryFp != NULL) {
-    SQueryExecRes* pRes = &pRequest->body.resInfo.execRes;
+    SExecResult* pRes = &pRequest->body.resInfo.execRes;
 
     if (code == TSDB_CODE_SUCCESS) {
       SCatalog* pCatalog = NULL;
diff --git a/source/client/src/clientStmt.c b/source/client/src/clientStmt.c
index 1c0caec810..1e0f30695d 100644
--- a/source/client/src/clientStmt.c
+++ b/source/client/src/clientStmt.c
@@ -324,9 +324,9 @@ int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
 }
 
 int32_t stmtRebuildDataBlock(STscStmt* pStmt, STableDataBlocks* pDataBlock, STableDataBlocks** newBlock, uint64_t uid) {
-  SEpSet      ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
-  SVgroupInfo vgInfo = {0};
-  SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter, 
+  SEpSet           ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
+  SVgroupInfo      vgInfo = {0};
+  SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter,
                            .requestId = pStmt->exec.pRequest->requestId,
                            .requestObjRefId = pStmt->exec.pRequest->self,
                            .mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)};
@@ -391,13 +391,12 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
     STMT_RET(stmtCleanBindInfo(pStmt));
   }
 
-  STableMeta* pTableMeta = NULL;
-  SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter, 
+  STableMeta*      pTableMeta = NULL;
+  SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter,
                            .requestId = pStmt->exec.pRequest->requestId,
                            .requestObjRefId = pStmt->exec.pRequest->self,
                            .mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)};
-  int32_t     code =
-      catalogGetTableMeta(pStmt->pCatalog, &conn, &pStmt->bInfo.sname, &pTableMeta);
+  int32_t          code = catalogGetTableMeta(pStmt->pCatalog, &conn, &pStmt->bInfo.sname, &pTableMeta);
   if (TSDB_CODE_PAR_TABLE_NOT_EXIST == code) {
     STMT_ERR_RET(stmtCleanBindInfo(pStmt));
 
@@ -849,7 +848,7 @@ int stmtIsInsert(TAOS_STMT* stmt, int* insert) {
   if (pStmt->sql.type) {
     *insert = (STMT_TYPE_INSERT == pStmt->sql.type || STMT_TYPE_MULTI_INSERT == pStmt->sql.type);
   } else {
-    *insert = qIsInsertSql(pStmt->sql.sqlStr, 0);
+    *insert = qIsInsertValuesSql(pStmt->sql.sqlStr, pStmt->sql.sqlLen);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -861,7 +860,7 @@ int stmtGetTagFields(TAOS_STMT* stmt, int* nums, TAOS_FIELD_E** fields) {
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
     STMT_RET(TSDB_CODE_TSC_STMT_API_ERROR);
   }
-  
+
   STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
 
   if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
@@ -893,7 +892,7 @@ int stmtGetColFields(TAOS_STMT* stmt, int* nums, TAOS_FIELD_E** fields) {
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
     STMT_RET(TSDB_CODE_TSC_STMT_API_ERROR);
   }
-  
+
   STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
 
   if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
@@ -919,7 +918,6 @@ int stmtGetColFields(TAOS_STMT* stmt, int* nums, TAOS_FIELD_E** fields) {
   return TSDB_CODE_SUCCESS;
 }
 
-
 int stmtGetParamNum(TAOS_STMT* stmt, int* nums) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
@@ -952,13 +950,13 @@ int stmtGetParamNum(TAOS_STMT* stmt, int* nums) {
   return TSDB_CODE_SUCCESS;
 }
 
-int stmtGetParam(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
+int stmtGetParam(TAOS_STMT* stmt, int idx, int* type, int* bytes) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
     STMT_RET(TSDB_CODE_TSC_STMT_API_ERROR);
   }
-  
+
   STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
 
   if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
@@ -979,8 +977,8 @@ int stmtGetParam(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
     STMT_ERR_RET(stmtParseSql(pStmt));
   }
 
-  int32_t nums = 0;
-  TAOS_FIELD_E *pField = NULL;
+  int32_t       nums = 0;
+  TAOS_FIELD_E* pField = NULL;
   STMT_ERR_RET(stmtFetchColFields(stmt, &nums, &pField));
   if (idx >= nums) {
     tscError("idx %d is too big", idx);
diff --git a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
index d70ed09920..436282d9fe 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c
@@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dmMgmt.h"
 #include "dmNodes.h"
+#include "index.h"
 #include "qworker.h"
 
 static bool dmRequireNode(SDnode *pDnode, SMgmtWrapper *pWrapper) {
@@ -213,6 +214,7 @@ void dmCleanupDnode(SDnode *pDnode) {
   dmCleanupServer(pDnode);
   dmClearVars(pDnode);
   rpcCleanup();
+  indexCleanup();
   dDebug("dnode is closed, ptr:%p", pDnode);
 }
 
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 6770cd578a..156afb09fc 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -1373,9 +1373,9 @@ char *buildRetension(SArray *pRetension) {
 static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows, int64_t numOfTables,
                            bool sysDb, ESdbStatus objStatus, bool sysinfo) {
   int32_t cols = 0;
+  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;
+  char   *buf = taosMemoryMalloc(bytes);
 
-  int32_t     bytes = pShow->pMeta->pSchemas[cols].bytes;
-  char       *buf = taosMemoryMalloc(bytes);
   const char *name = mndGetDbStr(pDb->name);
   if (name != NULL) {
     STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);
@@ -1383,11 +1383,11 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
     STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);
   }
 
-  char *status = "ready";
-  if (objStatus == SDB_STATUS_CREATING) status = "creating";
-  if (objStatus == SDB_STATUS_DROPPING) status = "dropping";
-  char statusB[24] = {0};
-  STR_WITH_SIZE_TO_VARSTR(statusB, status, strlen(status));
+  char *statusStr = "ready";
+  if (objStatus == SDB_STATUS_CREATING) statusStr = "creating";
+  if (objStatus == SDB_STATUS_DROPPING) statusStr = "dropping";
+  char statusVstr[24] = {0};
+  STR_WITH_SIZE_TO_VARSTR(statusVstr, statusStr, strlen(statusStr));
 
   if (sysDb || !sysinfo) {
     for (int32_t i = 0; i < pShow->numOfColumns; ++i) {
@@ -1397,7 +1397,7 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
       } else if (i == 3) {
         colDataAppend(pColInfo, rows, (const char *)&numOfTables, false);
       } else if (i == 20) {
-        colDataAppend(pColInfo, rows, statusB, false);
+        colDataAppend(pColInfo, rows, statusVstr, false);
       } else {
         colDataAppendNULL(pColInfo, rows);
       }
@@ -1405,7 +1405,6 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
   } else {
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, buf, false);
-    taosMemoryFree(buf);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->createdTime, false);
@@ -1419,30 +1418,29 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
 
-    const char *src = pDb->cfg.strict ? "strict" : "no_strict";
-    char        strict[24] = {0};
-    STR_WITH_SIZE_TO_VARSTR(strict, src, strlen(src));
+    const char *strictStr = pDb->cfg.strict ? "strict" : "no_strict";
+    char        strictVstr[24] = {0};
+    STR_WITH_SIZE_TO_VARSTR(strictVstr, strictStr, strlen(strictStr));
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)strict, false);
+    colDataAppend(pColInfo, rows, (const char *)strictVstr, false);
 
-    char    tmp[128] = {0};
-    int32_t len = 0;
-    len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.daysPerFile);
-    varDataSetLen(tmp, len);
+    char    durationVstr[128] = {0};
+    int32_t len = sprintf(&durationVstr[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.daysPerFile);
+    varDataSetLen(durationVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)tmp, false);
+    colDataAppend(pColInfo, rows, (const char *)durationVstr, false);
 
+    char keepVstr[128] = {0};
     if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
-      len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%dm,%dm,%dm", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2,
+      len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%dm,%dm,%dm", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2,
                     pDb->cfg.daysToKeep0);
     } else {
-      len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%dm,%dm,%dm", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1,
+      len = sprintf(&keepVstr[VARSTR_HEADER_SIZE], "%dm,%dm,%dm", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1,
                     pDb->cfg.daysToKeep2);
     }
-
-    varDataSetLen(tmp, len);
+    varDataSetLen(keepVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)tmp, false);
+    colDataAppend(pColInfo, rows, (const char *)keepVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.buffer, false);
@@ -1469,68 +1467,49 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-
-    STR_WITH_SIZE_TO_VARSTR(strict, src, strlen(src));
-#if 0
-    char cacheModel[24] = {0};
-    bool null = false;
-    if (pDb->cfg.cacheLastRow == 0) {
-      STR_TO_VARSTR(cacheModel, "no_cache");
-    } else if (pDb->cfg.cacheLastRow == 1) {
-      STR_TO_VARSTR(cacheModel, "last_row_cache")
-    } else {
-      null = true;
-    }
-    colDataAppend(pColInfo, rows, cacheModel, null);
-#endif
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.cacheLastRow, false);
 
-    char *prec = NULL;
+    const char *precStr = NULL;
     switch (pDb->cfg.precision) {
       case TSDB_TIME_PRECISION_MILLI:
-        prec = TSDB_TIME_PRECISION_MILLI_STR;
+        precStr = TSDB_TIME_PRECISION_MILLI_STR;
         break;
       case TSDB_TIME_PRECISION_MICRO:
-        prec = TSDB_TIME_PRECISION_MICRO_STR;
+        precStr = TSDB_TIME_PRECISION_MICRO_STR;
         break;
       case TSDB_TIME_PRECISION_NANO:
-        prec = TSDB_TIME_PRECISION_NANO_STR;
+        precStr = TSDB_TIME_PRECISION_NANO_STR;
         break;
       default:
-        prec = "none";
+        precStr = "none";
         break;
     }
-
-    char t[10] = {0};
-    STR_WITH_SIZE_TO_VARSTR(t, prec, 2);
+    char precVstr[10] = {0};
+    STR_WITH_SIZE_TO_VARSTR(precVstr, precStr, 2);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)t, false);
+    colDataAppend(pColInfo, rows, (const char *)precVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)statusB, false);
-
-    //    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    //    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.schemaless, false);
-
-    char *p = buildRetension(pDb->cfg.pRetensions);
+    colDataAppend(pColInfo, rows, (const char *)statusVstr, false);
 
+    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
-    if (p == NULL) {
+    if (rentensionVstr == NULL) {
       colDataAppendNULL(pColInfo, rows);
     } else {
-      colDataAppend(pColInfo, rows, (const char *)p, false);
-      taosMemoryFree(p);
+      colDataAppend(pColInfo, rows, (const char *)rentensionVstr, false);
+      taosMemoryFree(rentensionVstr);
     }
   }
+
+  taosMemoryFree(buf);
 }
 
 static void setInformationSchemaDbCfg(SDbObj *pDbObj) {
-  ASSERT(pDbObj != NULL);
-  strncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));
-
+  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));
   pDbObj->createdTime = 0;
   pDbObj->cfg.numOfVgroups = 0;
   pDbObj->cfg.strict = 1;
@@ -1539,9 +1518,7 @@ static void setInformationSchemaDbCfg(SDbObj *pDbObj) {
 }
 
 static void setPerfSchemaDbCfg(SDbObj *pDbObj) {
-  ASSERT(pDbObj != NULL);
-  strncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));
-
+  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));
   pDbObj->createdTime = 0;
   pDbObj->cfg.numOfVgroups = 0;
   pDbObj->cfg.strict = 1;
@@ -1585,14 +1562,11 @@ static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
 
   while (numOfRows < rowsCapacity) {
     pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus);
-    if (pShow->pIter == NULL) {
-      break;
-    }
+    if (pShow->pIter == NULL) break;
 
     if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) == 0) {
       int32_t numOfTables = 0;
       sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, NULL, NULL);
-
       dumpDbInfoData(pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo);
       numOfRows++;
     }
diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index 2d12d57fbd..ce42b0ab67 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -75,25 +75,13 @@ int32_t tsdbLastRowReaderOpen(void* pVnode, int32_t type, SArray* pTableIdList,
   STableKeyInfo* pKeyInfo = taosArrayGet(pTableIdList, 0);
   p->pSchema = metaGetTbTSchema(p->pVnode->pMeta, pKeyInfo->uid, -1);
   p->pTableList = pTableIdList;
-#if 0
+
   for(int32_t i = 0; i < p->numOfCols; ++i) {
-    for(int32_t j = 0; j < p->pSchema->numOfCols; ++j) {
-      if (colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {
-        p->pSlotIds[i] = -1;
-        break;
-      }
-
-      if (colId[i] == p->pSchema->columns[j].colId) {
-        p->pSlotIds[i] = j;
-        break;
-      }
-    }
-
     if (IS_VAR_DATA_TYPE(colId[i])) {
-      p->transferBuf[i] = taosMemoryMalloc(p->pSchema->columns[p->pSlotIds[i]].bytes);
+      p->transferBuf[i] = taosMemoryMalloc(p->pSchema->columns[i].bytes);
     }
   }
-#endif
+
   *pReader = p;
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit.c b/source/dnode/vnode/src/tsdb/tsdbCommit.c
index 9c0cafd6f2..5d7b7a611c 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCommit.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit.c
@@ -527,7 +527,7 @@ static int32_t tsdbCommitTableMemData(SCommitter *pCommitter, STbDataIter *pIter
     // crash on CI, use the block following
     if (pRow) {
       TSDBKEY key = TSDBROW_KEY(pRow);
-      if (tsdbKeyCmprFn(&TSDBROW_KEY(pRow), &toKey) >= 0) {
+      if (tsdbKeyCmprFn(&key, &toKey) >= 0) {
         pRow = NULL;
       }
     }
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 0e7e4361f0..ae9caa3444 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -212,6 +212,20 @@ static SHashObj* createDataBlockScanInfo(STsdbReader* pTsdbReader, const STableK
   return pTableMap;
 }
 
+static void resetDataBlockScanInfo(SHashObj* pTableMap) {
+  STableBlockScanInfo* p = NULL;
+
+  while((p = taosHashIterate(pTableMap, p)) != NULL) {
+    p->iterInit = false;
+    p->iiter.hasVal = false;
+    if (p->iter.iter != NULL)  {
+      tsdbTbDataIterDestroy(p->iter.iter);
+    }
+
+    taosArrayDestroy(p->delSkyline);
+  }
+}
+
 static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {
   ASSERT(pWindow != NULL);
   return pWindow->skey > pWindow->ekey;
@@ -3157,37 +3171,6 @@ bool tsdbNextDataBlock(STsdbReader* pReader) {
   } else {
     ASSERT(0);
   }
-  // if (pReader->loadType == BLOCK_LOAD_TABLE_SEQ_ORDER) {
-  //   return loadDataBlockFromTableSeq(pReader);
-  // } else {  // loadType == RR and Offset Order
-  //   if (pReader->checkFiles) {
-  //     // check if the query range overlaps with the file data block
-  //     bool exists = true;
-  //     int32_t code = buildBlockFromFiles(pReader, &exists);
-  //     if (code != TSDB_CODE_SUCCESS) {
-  //       pReader->activeIndex = 0;
-  //       pReader->checkFiles = false;
-
-  //       return false;
-  //     }
-
-  //     if (exists) {
-  //       pReader->cost.checkForNextTime += (taosGetTimestampUs() - stime);
-  //       return exists;
-  //     }
-
-  //     pReader->activeIndex = 0;
-  //     pReader->checkFiles = false;
-  //   }
-
-  //   // TODO: opt by consider the scan order
-  //   bool ret = doHasDataInBuffer(pReader);
-  //   terrno = TSDB_CODE_SUCCESS;
-
-  //   elapsedTime = taosGetTimestampUs() - stime;
-  //   pReader->cost.checkForNextTime += elapsedTime;
-  //   return ret;
-  // }
   return false;
 }
 
@@ -3305,10 +3288,10 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond, int32_
 
   setQueryTimewindow(pReader, pCond, tWinIdx);
 
-  pReader->order = pCond->order;
-  pReader->type = BLOCK_LOAD_OFFSET_ORDER;
+  pReader->order               = pCond->order;
+  pReader->type                = BLOCK_LOAD_OFFSET_ORDER;
   pReader->status.loadFromFile = true;
-  pReader->status.pTableIter = NULL;
+  pReader->status.pTableIter   = NULL;
 
   pReader->window = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows[tWinIdx]);
 
@@ -3323,6 +3306,7 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond, int32_
   STsdbFSState* pFState = pReader->pTsdb->fs->cState;
   initFilesetIterator(&pReader->status.fileIter, pFState, pReader->order, pReader->idStr);
   resetDataBlockIterator(&pReader->status.blockIter, pReader->order);
+  resetDataBlockScanInfo(pReader->status.pTableMap);
 
   int32_t code = 0;
   // no data in files, let's try buffer in memory
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 0276a3dfde..de5f69be33 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -240,7 +240,7 @@ typedef struct SColMatchInfo {
   int32_t srcSlotId;     // source slot id
   int32_t colId;
   int32_t targetSlotId;
-  bool    output;
+  bool    output;        // todo remove this?
   bool    reserved;
   int32_t matchType;     // determinate the source according to col id or slot id
 } SColMatchInfo;
diff --git a/source/libs/executor/src/dataInserter.c b/source/libs/executor/src/dataInserter.c
new file mode 100644
index 0000000000..c424cb33fa
--- /dev/null
+++ b/source/libs/executor/src/dataInserter.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dataSinkInt.h"
+#include "dataSinkMgt.h"
+#include "executorimpl.h"
+#include "planner.h"
+#include "tcompression.h"
+#include "tdatablock.h"
+#include "tglobal.h"
+#include "tqueue.h"
+
+extern SDataSinkStat gDataSinkStat;
+
+typedef struct SDataInserterBuf {
+  int32_t useSize;
+  int32_t allocSize;
+  char*   pData;
+} SDataInserterBuf;
+
+typedef struct SDataCacheEntry {
+  int32_t dataLen;
+  int32_t numOfRows;
+  int32_t numOfCols;
+  int8_t  compressed;
+  char    data[];
+} SDataCacheEntry;
+
+typedef struct SDataInserterHandle {
+  SDataSinkHandle     sink;
+  SDataSinkManager*   pManager;
+  SDataBlockDescNode* pSchema;
+  SDataDeleterNode*   pDeleter;
+  SDeleterParam*      pParam;
+  STaosQueue*         pDataBlocks;
+  SDataInserterBuf    nextOutput;
+  int32_t             status;
+  bool                queryEnd;
+  uint64_t            useconds;
+  uint64_t            cachedSize;
+  TdThreadMutex       mutex;
+} SDataInserterHandle;
+
+static bool needCompress(const SSDataBlock* pData, int32_t numOfCols) {
+  if (tsCompressColData < 0 || 0 == pData->info.rows) {
+    return false;
+  }
+
+  for (int32_t col = 0; col < numOfCols; ++col) {
+    SColumnInfoData* pColRes = taosArrayGet(pData->pDataBlock, col);
+    int32_t          colSize = pColRes->info.bytes * pData->info.rows;
+    if (NEEDTO_COMPRESS_QUERY(colSize)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static void toDataCacheEntry(SDataInserterHandle* pHandle, const SInputData* pInput, SDataInserterBuf* pBuf) {
+  int32_t numOfCols = LIST_LENGTH(pHandle->pSchema->pSlots);
+
+  SDataCacheEntry* pEntry = (SDataCacheEntry*)pBuf->pData;
+  pEntry->compressed = 0;
+  pEntry->numOfRows = pInput->pData->info.rows;
+  pEntry->numOfCols = taosArrayGetSize(pInput->pData->pDataBlock);
+  pEntry->dataLen = sizeof(SDeleterRes);
+
+  ASSERT(1 == pEntry->numOfRows);
+  ASSERT(1 == pEntry->numOfCols);
+
+  pBuf->useSize = sizeof(SDataCacheEntry);
+
+  SColumnInfoData* pColRes = (SColumnInfoData*)taosArrayGet(pInput->pData->pDataBlock, 0);
+
+  SDeleterRes* pRes = (SDeleterRes*)pEntry->data;
+  pRes->suid = pHandle->pParam->suid;
+  pRes->uidList = pHandle->pParam->pUidList;
+  pRes->skey = pHandle->pDeleter->deleteTimeRange.skey;
+  pRes->ekey = pHandle->pDeleter->deleteTimeRange.ekey;
+  pRes->affectedRows = *(int64_t*)pColRes->pData;
+
+  pBuf->useSize += pEntry->dataLen;
+  
+  atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen); 
+  atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); 
+}
+
+static bool allocBuf(SDataInserterHandle* pDeleter, const SInputData* pInput, SDataInserterBuf* pBuf) {
+  uint32_t capacity = pDeleter->pManager->cfg.maxDataBlockNumPerQuery;
+  if (taosQueueItemSize(pDeleter->pDataBlocks) > capacity) {
+    qError("SinkNode queue is full, no capacity, max:%d, current:%d, no capacity", capacity,
+           taosQueueItemSize(pDeleter->pDataBlocks));
+    return false;
+  }
+
+  pBuf->allocSize = sizeof(SDataCacheEntry) + sizeof(SDeleterRes);
+
+  pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
+  if (pBuf->pData == NULL) {
+    qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
+  }
+
+  return NULL != pBuf->pData;
+}
+
+static int32_t updateStatus(SDataInserterHandle* pDeleter) {
+  taosThreadMutexLock(&pDeleter->mutex);
+  int32_t blockNums = taosQueueItemSize(pDeleter->pDataBlocks);
+  int32_t status =
+      (0 == blockNums ? DS_BUF_EMPTY
+                      : (blockNums < pDeleter->pManager->cfg.maxDataBlockNumPerQuery ? DS_BUF_LOW : DS_BUF_FULL));
+  pDeleter->status = status;
+  taosThreadMutexUnlock(&pDeleter->mutex);
+  return status;
+}
+
+static int32_t getStatus(SDataInserterHandle* pDeleter) {
+  taosThreadMutexLock(&pDeleter->mutex);
+  int32_t status = pDeleter->status;
+  taosThreadMutexUnlock(&pDeleter->mutex);
+  return status;
+}
+
+static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) {
+  SDataInserterHandle* pDeleter = (SDataInserterHandle*)pHandle;
+  SDataInserterBuf*    pBuf = taosAllocateQitem(sizeof(SDataInserterBuf), DEF_QITEM);
+  if (NULL == pBuf || !allocBuf(pDeleter, pInput, pBuf)) {
+    return TSDB_CODE_QRY_OUT_OF_MEMORY;
+  }
+  toDataCacheEntry(pDeleter, pInput, pBuf);
+  taosWriteQitem(pDeleter->pDataBlocks, pBuf);
+  *pContinue = (DS_BUF_LOW == updateStatus(pDeleter) ? true : false);
+  return TSDB_CODE_SUCCESS;
+}
+
+static void endPut(struct SDataSinkHandle* pHandle, uint64_t useconds) {
+  SDataInserterHandle* pDeleter = (SDataInserterHandle*)pHandle;
+  taosThreadMutexLock(&pDeleter->mutex);
+  pDeleter->queryEnd = true;
+  pDeleter->useconds = useconds;
+  taosThreadMutexUnlock(&pDeleter->mutex);
+}
+
+static void getDataLength(SDataSinkHandle* pHandle, int32_t* pLen, bool* pQueryEnd) {
+  SDataInserterHandle* pDeleter = (SDataInserterHandle*)pHandle;
+  if (taosQueueEmpty(pDeleter->pDataBlocks)) {
+    *pQueryEnd = pDeleter->queryEnd;
+    *pLen = 0;
+    return;
+  }
+
+  SDataInserterBuf* pBuf = NULL;
+  taosReadQitem(pDeleter->pDataBlocks, (void**)&pBuf);
+  memcpy(&pDeleter->nextOutput, pBuf, sizeof(SDataInserterBuf));
+  taosFreeQitem(pBuf);
+  *pLen = ((SDataCacheEntry*)(pDeleter->nextOutput.pData))->dataLen;
+  *pQueryEnd = pDeleter->queryEnd;
+  qDebug("got data len %d, row num %d in sink", *pLen, ((SDataCacheEntry*)(pDeleter->nextOutput.pData))->numOfRows);
+}
+
+static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
+  SDataInserterHandle* pDeleter = (SDataInserterHandle*)pHandle;
+  if (NULL == pDeleter->nextOutput.pData) {
+    assert(pDeleter->queryEnd);
+    pOutput->useconds = pDeleter->useconds;
+    pOutput->precision = pDeleter->pSchema->precision;
+    pOutput->bufStatus = DS_BUF_EMPTY;
+    pOutput->queryEnd = pDeleter->queryEnd;
+    return TSDB_CODE_SUCCESS;
+  }
+  SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDeleter->nextOutput.pData);
+  memcpy(pOutput->pData, pEntry->data, pEntry->dataLen);
+  pOutput->numOfRows = pEntry->numOfRows;
+  pOutput->numOfCols = pEntry->numOfCols;
+  pOutput->compressed = pEntry->compressed;
+
+  atomic_sub_fetch_64(&pDeleter->cachedSize, pEntry->dataLen);  
+  atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen); 
+
+  taosMemoryFreeClear(pDeleter->nextOutput.pData);  // todo persistent
+  pOutput->bufStatus = updateStatus(pDeleter);
+  taosThreadMutexLock(&pDeleter->mutex);
+  pOutput->queryEnd = pDeleter->queryEnd;
+  pOutput->useconds = pDeleter->useconds;
+  pOutput->precision = pDeleter->pSchema->precision;
+  taosThreadMutexUnlock(&pDeleter->mutex);
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t destroyDataSinker(SDataSinkHandle* pHandle) {
+  SDataInserterHandle* pDeleter = (SDataInserterHandle*)pHandle;
+  atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pDeleter->cachedSize);
+  taosMemoryFreeClear(pDeleter->nextOutput.pData);
+  while (!taosQueueEmpty(pDeleter->pDataBlocks)) {
+    SDataInserterBuf* pBuf = NULL;
+    taosReadQitem(pDeleter->pDataBlocks, (void**)&pBuf);
+    taosMemoryFreeClear(pBuf->pData);
+    taosFreeQitem(pBuf);
+  }
+  taosCloseQueue(pDeleter->pDataBlocks);
+  taosThreadMutexDestroy(&pDeleter->mutex);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t getCacheSize(struct SDataSinkHandle* pHandle, uint64_t* size) {
+  SDataInserterHandle* pDispatcher = (SDataInserterHandle*)pHandle;
+
+  *size = atomic_load_64(&pDispatcher->cachedSize);
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t createDataInserter(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle, void *pParam) {
+  SDataInserterHandle* inserter = taosMemoryCalloc(1, sizeof(SDataInserterHandle));
+  if (NULL == inserter) {
+    terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    return TSDB_CODE_QRY_OUT_OF_MEMORY;
+  }
+
+  SDataDeleterNode* pDeleterNode = (SDataDeleterNode *)pDataSink;
+  inserter->sink.fPut = putDataBlock;
+  inserter->sink.fEndPut = endPut;
+  inserter->sink.fGetLen = getDataLength;
+  inserter->sink.fGetData = getDataBlock;
+  inserter->sink.fDestroy = destroyDataSinker;
+  inserter->sink.fGetCacheSize = getCacheSize;
+  inserter->pManager = pManager;
+  inserter->pDeleter = pDeleterNode;
+  inserter->pSchema = pDataSink->pInputDataBlockDesc;
+  inserter->pParam = pParam;
+  inserter->status = DS_BUF_EMPTY;
+  inserter->queryEnd = false;
+  inserter->pDataBlocks = taosOpenQueue();
+  taosThreadMutexInit(&inserter->mutex, NULL);
+  if (NULL == inserter->pDataBlocks) {
+    terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    return TSDB_CODE_QRY_OUT_OF_MEMORY;
+  }
+  *pHandle = inserter;
+  return TSDB_CODE_SUCCESS;
+}
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 6122c77154..2d2f9bab38 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -704,7 +704,7 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray
   while (i < numOfSrcCols && j < taosArrayGetSize(pColMatchInfo)) {
     SColumnInfoData* p = taosArrayGet(pCols, i);
     SColMatchInfo*   pmInfo = taosArrayGet(pColMatchInfo, j);
-    if (!outputEveryColumn && !pmInfo->output) {
+    if (!outputEveryColumn && pmInfo->reserved) {
       j++;
       continue;
     }
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index c30d047c47..e1b747f2d2 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -3992,9 +3992,9 @@ int32_t extractTableSchemaVersion(SReadHandle* pHandle, uint64_t uid, SExecTaskI
   SMetaReader mr = {0};
   metaReaderInit(&mr, pHandle->meta, 0);
   int32_t code = metaGetTableEntryByUid(&mr, uid);
-  if (code) {
+  if (code != TSDB_CODE_SUCCESS) {
     metaReaderClear(&mr);
-    return code;
+    return terrno;
   }
 
   pTaskInfo->schemaVer.tablename = strdup(mr.me.name);
@@ -4307,6 +4307,10 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
 //      }
 
       int32_t code = extractTableSchemaVersion(pHandle, pScanNode->uid, pTaskInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        pTaskInfo->code = code;
+        return NULL;
+      }
 
       pTableListInfo->pTableList = taosArrayInit(4, sizeof(STableKeyInfo));
       if (pScanNode->tableType == TSDB_SUPER_TABLE) {
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 175e686ca0..b3a00cd6f2 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -2438,8 +2438,9 @@ int32_t stopGroupTableMergeScan(SOperatorInfo* pOperator) {
     STsdbReader* reader = taosArrayGetP(pInfo->dataReaders, i);
     tsdbReaderClose(reader);
   }
-  taosArrayDestroy(pInfo->dataReaders);
 
+  taosArrayDestroy(pInfo->dataReaders);
+  pInfo->dataReaders = NULL;
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index 1009518970..c89f11790b 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -605,7 +605,7 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   }
 
   SValueNode* pValue = (SValueNode*)pParamNode1;
-  if (pValue->node.resType.type != TSDB_DATA_TYPE_BIGINT) {
+  if (!IS_INTEGER_TYPE(pValue->node.resType.type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -2210,7 +2210,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
   {
     .name = "last_row",
     .type = FUNCTION_TYPE_LAST_ROW,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_TIMELINE_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC,
     .translateFunc = translateFirstLast,
     .getEnvFunc   = getFirstLastFuncEnv,
     .initFunc     = functionSetup,
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 800c3bf38c..f94522f0d8 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -90,12 +90,14 @@ typedef struct SStddevRes {
   double  result;
   int64_t count;
   union {
-    double  quadraticDSum;
-    int64_t quadraticISum;
+    double   quadraticDSum;
+    int64_t  quadraticISum;
+    uint64_t quadraticUSum;
   };
   union {
-    double  dsum;
-    int64_t isum;
+    double   dsum;
+    int64_t  isum;
+    uint64_t usum;
   };
   int16_t type;
 } SStddevRes;
@@ -1729,6 +1731,68 @@ int32_t stddevFunction(SqlFunctionCtx* pCtx) {
       break;
     }
 
+    case TSDB_DATA_TYPE_UTINYINT: {
+      uint8_t* plist = (uint8_t*)pCol->pData;
+      for (int32_t i = start; i < numOfRows + start; ++i) {
+        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        numOfElem += 1;
+        pStddevRes->count += 1;
+        pStddevRes->usum += plist[i];
+        pStddevRes->quadraticISum += plist[i] * plist[i];
+      }
+
+      break;
+    }
+
+    case TSDB_DATA_TYPE_USMALLINT: {
+      uint16_t* plist = (uint16_t*)pCol->pData;
+      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
+        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        numOfElem += 1;
+        pStddevRes->count += 1;
+        pStddevRes->usum += plist[i];
+        pStddevRes->quadraticISum += plist[i] * plist[i];
+      }
+      break;
+    }
+
+    case TSDB_DATA_TYPE_UINT: {
+      uint32_t* plist = (uint32_t*)pCol->pData;
+      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
+        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        numOfElem += 1;
+        pStddevRes->count += 1;
+        pStddevRes->usum += plist[i];
+        pStddevRes->quadraticISum += plist[i] * plist[i];
+      }
+
+      break;
+    }
+
+    case TSDB_DATA_TYPE_UBIGINT: {
+      uint64_t* plist = (uint64_t*)pCol->pData;
+      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
+        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        numOfElem += 1;
+        pStddevRes->count += 1;
+        pStddevRes->usum += plist[i];
+        pStddevRes->quadraticISum += plist[i] * plist[i];
+      }
+      break;
+    }
+
     case TSDB_DATA_TYPE_FLOAT: {
       float* plist = (float*)pCol->pData;
       for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
@@ -1771,9 +1835,12 @@ _stddev_over:
 
 static void stddevTransferInfo(SStddevRes* pInput, SStddevRes* pOutput) {
   pOutput->type = pInput->type;
-  if (IS_INTEGER_TYPE(pOutput->type)) {
+  if (IS_SIGNED_NUMERIC_TYPE(pOutput->type)) {
     pOutput->quadraticISum += pInput->quadraticISum;
     pOutput->isum += pInput->isum;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(pOutput->type)) {
+    pOutput->quadraticUSum += pInput->quadraticUSum;
+    pOutput->usum += pInput->usum;
   } else {
     pOutput->quadraticDSum += pInput->quadraticDSum;
     pOutput->dsum += pInput->dsum;
@@ -1848,6 +1915,22 @@ int32_t stddevInvertFunction(SqlFunctionCtx* pCtx) {
       LIST_STDDEV_SUB_N(pStddevRes->isum, int64_t);
       break;
     }
+    case TSDB_DATA_TYPE_UTINYINT: {
+      LIST_STDDEV_SUB_N(pStddevRes->isum, uint8_t);
+      break;
+    }
+    case TSDB_DATA_TYPE_USMALLINT: {
+      LIST_STDDEV_SUB_N(pStddevRes->isum, uint16_t);
+      break;
+    }
+    case TSDB_DATA_TYPE_UINT: {
+      LIST_STDDEV_SUB_N(pStddevRes->isum, uint32_t);
+      break;
+    }
+    case TSDB_DATA_TYPE_UBIGINT: {
+      LIST_STDDEV_SUB_N(pStddevRes->isum, uint64_t);
+      break;
+    }
     case TSDB_DATA_TYPE_FLOAT: {
       LIST_STDDEV_SUB_N(pStddevRes->dsum, float);
       break;
@@ -1871,9 +1954,12 @@ int32_t stddevFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   int32_t               type = pStddevRes->type;
   double                avg;
 
-  if (IS_INTEGER_TYPE(type)) {
+  if (IS_SIGNED_NUMERIC_TYPE(type)) {
     avg = pStddevRes->isum / ((double)pStddevRes->count);
     pStddevRes->result = sqrt(fabs(pStddevRes->quadraticISum / ((double)pStddevRes->count) - avg * avg));
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    avg = pStddevRes->usum / ((double)pStddevRes->count);
+    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticUSum / ((double)pStddevRes->count) - avg * avg));
   } else {
     avg = pStddevRes->dsum / ((double)pStddevRes->count);
     pStddevRes->result = sqrt(fabs(pStddevRes->quadraticDSum / ((double)pStddevRes->count) - avg * avg));
@@ -1913,9 +1999,12 @@ int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
   SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
   SStddevRes*          pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
 
-  if (IS_INTEGER_TYPE(type)) {
+  if (IS_SIGNED_NUMERIC_TYPE(type)) {
     pDBuf->isum += pSBuf->isum;
     pDBuf->quadraticISum += pSBuf->quadraticISum;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    pDBuf->usum += pSBuf->usum;
+    pDBuf->quadraticUSum += pSBuf->quadraticUSum;
   } else {
     pDBuf->dsum += pSBuf->dsum;
     pDBuf->quadraticDSum += pSBuf->quadraticDSum;
diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c
index f6424ee8a5..7f5cfc7767 100644
--- a/source/libs/index/src/index.c
+++ b/source/libs/index/src/index.c
@@ -65,9 +65,10 @@ void indexInit() {
   indexQhandle = taosInitScheduler(INDEX_QUEUE_SIZE, INDEX_NUM_OF_THREADS, "index");
   indexRefMgt = taosOpenRef(10, indexDestroy);
 }
-void indexCleanUp() {
+void indexCleanup() {
   // refacto later
   taosCleanUpScheduler(indexQhandle);
+  taosCloseRef(indexRefMgt);
 }
 
 typedef struct SIdxColInfo {
diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c
index 25a41fb15c..1a1aca8bdb 100644
--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@@ -165,7 +165,7 @@ static int32_t valueNodeCopy(const SValueNode* pSrc, SValueNode* pDst) {
       memcpy(pDst->datum.p, pSrc->datum.p, len);
       break;
     }
-    case TSDB_DATA_TYPE_JSON:{
+    case TSDB_DATA_TYPE_JSON: {
       int32_t len = getJsonValueLen(pSrc->datum.p);
       pDst->datum.p = taosMemoryCalloc(1, len);
       if (NULL == pDst->datum.p) {
@@ -397,6 +397,7 @@ static int32_t logicVnodeModifCopy(const SVnodeModifyLogicNode* pSrc, SVnodeModi
   COPY_SCALAR_FIELD(tableType);
   COPY_CHAR_ARRAY_FIELD(tableFName);
   COPY_OBJECT_FIELD(deleteTimeRange, sizeof(STimeWindow));
+  CLONE_OBJECT_FIELD(pVgroupList, vgroupsInfoClone);
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c
index 34f92dac0b..44bfa39dbd 100644
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -19,8 +19,8 @@
 #include "query.h"
 #include "querynodes.h"
 #include "taoserror.h"
-#include "tjson.h"
 #include "tdatablock.h"
+#include "tjson.h"
 
 static int32_t nodeToJson(const void* pObj, SJson* pJson);
 static int32_t jsonToNode(const SJson* pJson, void* pObj);
@@ -179,6 +179,8 @@ const char* nodesNodeName(ENodeType type) {
       return "ShowVnodeStmt";
     case QUERY_NODE_DELETE_STMT:
       return "DeleteStmt";
+    case QUERY_NODE_INSERT_STMT:
+      return "InsertStmt";
     case QUERY_NODE_LOGIC_PLAN_SCAN:
       return "LogicScan";
     case QUERY_NODE_LOGIC_PLAN_JOIN:
@@ -271,6 +273,8 @@ const char* nodesNodeName(ENodeType type) {
       return "PhysiDispatch";
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
       return "PhysiInsert";
+    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
+      return "PhysiQueryInsert";
     case QUERY_NODE_PHYSICAL_PLAN_DELETE:
       return "PhysiDelete";
     case QUERY_NODE_PHYSICAL_SUBPLAN:
@@ -2210,6 +2214,58 @@ static int32_t physiDispatchNodeToJson(const void* pObj, SJson* pJson) { return
 
 static int32_t jsonToPhysiDispatchNode(const SJson* pJson, void* pObj) { return jsonToPhysicDataSinkNode(pJson, pObj); }
 
+static const char* jkQueryInsertPhysiPlanTableId = "TableId";
+static const char* jkQueryInsertPhysiPlanTableType = "TableType";
+static const char* jkQueryInsertPhysiPlanTableFName = "TableFName";
+static const char* jkQueryInsertPhysiPlanVgId = "VgId";
+static const char* jkQueryInsertPhysiPlanEpSet = "EpSet";
+
+static int32_t physiQueryInsertNodeToJson(const void* pObj, SJson* pJson) {
+  const SQueryInserterNode* pNode = (const SQueryInserterNode*)pObj;
+
+  int32_t code = physicDataSinkNodeToJson(pObj, pJson);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkQueryInsertPhysiPlanTableId, pNode->tableId);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkQueryInsertPhysiPlanTableType, pNode->tableType);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddStringToObject(pJson, jkQueryInsertPhysiPlanTableFName, pNode->tableFName);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkQueryInsertPhysiPlanVgId, pNode->vgId);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddObject(pJson, jkQueryInsertPhysiPlanEpSet, epSetToJson, &pNode->epSet);
+  }
+
+  return code;
+}
+
+static int32_t jsonToPhysiQueryInsertNode(const SJson* pJson, void* pObj) {
+  SQueryInserterNode* pNode = (SQueryInserterNode*)pObj;
+
+  int32_t code = jsonToPhysicDataSinkNode(pJson, pObj);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetUBigIntValue(pJson, jkQueryInsertPhysiPlanTableId, &pNode->tableId);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetTinyIntValue(pJson, jkQueryInsertPhysiPlanTableType, &pNode->tableType);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetStringValue(pJson, jkQueryInsertPhysiPlanTableFName, pNode->tableFName);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetIntValue(pJson, jkQueryInsertPhysiPlanVgId, &pNode->vgId);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonToObject(pJson, jkQueryInsertPhysiPlanEpSet, jsonToEpSet, &pNode->epSet);
+  }
+
+  return code;
+}
+
 static const char* jkDeletePhysiPlanTableId = "TableId";
 static const char* jkDeletePhysiPlanTableType = "TableType";
 static const char* jkDeletePhysiPlanTableFName = "TableFName";
@@ -2641,9 +2697,9 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) {
     case TSDB_DATA_TYPE_VARBINARY:
       code = tjsonAddStringToObject(pJson, jkValueDatum, varDataVal(pNode->datum.p));
       break;
-    case TSDB_DATA_TYPE_JSON:{
+    case TSDB_DATA_TYPE_JSON: {
       int32_t len = getJsonValueLen(pNode->datum.p);
-      char* buf = taosMemoryCalloc( len * 2 + 1, sizeof(char));
+      char*   buf = taosMemoryCalloc(len * 2 + 1, sizeof(char));
       code = taosHexEncode(pNode->datum.p, buf, len);
       if (code != TSDB_CODE_SUCCESS) {
         taosMemoryFree(buf);
@@ -2775,7 +2831,7 @@ static int32_t jsonToDatum(const SJson* pJson, void* pObj) {
       }
       break;
     }
-    case TSDB_DATA_TYPE_JSON:{
+    case TSDB_DATA_TYPE_JSON: {
       pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes);
       if (NULL == pNode->datum.p) {
         code = TSDB_CODE_OUT_OF_MEMORY;
@@ -4232,6 +4288,8 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
       return physiDispatchNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
       break;
+    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
+      return physiQueryInsertNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_DELETE:
       return physiDeleteNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_SUBPLAN:
@@ -4374,6 +4432,8 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
       return jsonToPhysiInterpFuncNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
       return jsonToPhysiDispatchNode(pJson, pObj);
+    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
+      return jsonToPhysiQueryInsertNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_DELETE:
       return jsonToPhysiDeleteNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_SUBPLAN:
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index dfa19c1148..e15375e6ef 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -231,6 +231,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SKillStmt));
     case QUERY_NODE_DELETE_STMT:
       return makeNode(type, sizeof(SDeleteStmt));
+    case QUERY_NODE_INSERT_STMT:
+      return makeNode(type, sizeof(SInsertStmt));
     case QUERY_NODE_QUERY:
       return makeNode(type, sizeof(SQuery));
     case QUERY_NODE_LOGIC_PLAN_SCAN:
@@ -327,6 +329,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SDataDispatcherNode));
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
       return makeNode(type, sizeof(SDataInserterNode));
+    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
+      return makeNode(type, sizeof(SQueryInserterNode));
     case QUERY_NODE_PHYSICAL_PLAN_DELETE:
       return makeNode(type, sizeof(SDataDeleterNode));
     case QUERY_NODE_PHYSICAL_SUBPLAN:
@@ -694,6 +698,13 @@ void nodesDestroyNode(SNode* pNode) {
       nodesDestroyNode(pStmt->pTagCond);
       break;
     }
+    case QUERY_NODE_INSERT_STMT: {
+      SInsertStmt* pStmt = (SInsertStmt*)pNode;
+      nodesDestroyNode(pStmt->pTable);
+      nodesDestroyList(pStmt->pCols);
+      nodesDestroyNode(pStmt->pQuery);
+      break;
+    }
     case QUERY_NODE_QUERY: {
       SQuery* pQuery = (SQuery*)pNode;
       nodesDestroyNode(pQuery->pRoot);
@@ -929,6 +940,11 @@ void nodesDestroyNode(SNode* pNode) {
       taosMemoryFreeClear(pSink->pData);
       break;
     }
+    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: {
+      SQueryInserterNode* pSink = (SQueryInserterNode*)pNode;
+      destroyDataSinkNode((SDataSinkNode*)pSink);
+      break;
+    }
     case QUERY_NODE_PHYSICAL_PLAN_DELETE: {
       SDataDeleterNode* pSink = (SDataDeleterNode*)pNode;
       destroyDataSinkNode((SDataSinkNode*)pSink);
@@ -1528,7 +1544,6 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle
   }
 
   return TSDB_CODE_SUCCESS;
-
 }
 
 typedef struct SCollectFuncsCxt {
diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h
index 4ef10ab86b..835f8098a3 100644
--- a/source/libs/parser/inc/parAst.h
+++ b/source/libs/parser/inc/parAst.h
@@ -211,6 +211,7 @@ SNode* createSyncdbStmt(SAstCreateContext* pCxt, const SToken* pDbName);
 SNode* createGrantStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDbName, SToken* pUserName);
 SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDbName, SToken* pUserName);
 SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere);
+SNode* createInsertStmt(SAstCreateContext* pCxt, SNode* pTable, SNodeList* pCols, SNode* pQuery);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index c033b2c436..3c173aead9 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -260,7 +260,7 @@ multi_create_clause(A) ::= multi_create_clause(B) create_subtable_clause(C).
 
 create_subtable_clause(A) ::=
   not_exists_opt(B) full_table_name(C) USING full_table_name(D)
-  specific_tags_opt(E) TAGS NK_LP expression_list(F) NK_RP table_options(G).      { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); }
+  specific_cols_opt(E) TAGS NK_LP expression_list(F) NK_RP table_options(G).      { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); }
 
 %type multi_drop_clause                                                           { SNodeList* }
 %destructor multi_drop_clause                                                     { nodesDestroyList($$); }
@@ -269,10 +269,10 @@ multi_drop_clause(A) ::= multi_drop_clause(B) drop_table_clause(C).
 
 drop_table_clause(A) ::= exists_opt(B) full_table_name(C).                        { A = createDropTableClause(pCxt, B, C); }
 
-%type specific_tags_opt                                                           { SNodeList* }
-%destructor specific_tags_opt                                                     { nodesDestroyList($$); }
-specific_tags_opt(A) ::= .                                                        { A = NULL; }
-specific_tags_opt(A) ::= NK_LP col_name_list(B) NK_RP.                            { A = B; }
+%type specific_cols_opt                                                           { SNodeList* }
+%destructor specific_cols_opt                                                     { nodesDestroyList($$); }
+specific_cols_opt(A) ::= .                                                        { A = NULL; }
+specific_cols_opt(A) ::= NK_LP col_name_list(B) NK_RP.                            { A = B; }
 
 full_table_name(A) ::= table_name(B).                                             { A = createRealTableNode(pCxt, NULL, &B, NULL); }
 full_table_name(A) ::= db_name(B) NK_DOT table_name(C).                           { A = createRealTableNode(pCxt, &B, &C, NULL); }
@@ -516,6 +516,9 @@ cmd ::= DELETE FROM full_table_name(A) where_clause_opt(B).
 /************************************************ select **************************************************************/
 cmd ::= query_expression(A).                                                      { pCxt->pRootNode = A; }
 
+/************************************************ insert **************************************************************/
+cmd ::= INSERT INTO full_table_name(A) specific_cols_opt(B) query_expression(C).  { pCxt->pRootNode = createInsertStmt(pCxt, A, B, C); }
+
 /************************************************ literal *************************************************************/
 literal(A) ::= NK_INTEGER(B).                                                     { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B)); }
 literal(A) ::= NK_FLOAT(B).                                                       { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B)); }
@@ -974,4 +977,4 @@ null_ordering_opt(A) ::= .
 null_ordering_opt(A) ::= NULLS FIRST.                                             { A = NULL_ORDER_FIRST; }
 null_ordering_opt(A) ::= NULLS LAST.                                              { A = NULL_ORDER_LAST; }
 
-%fallback ID NK_BITNOT INSERT VALUES IMPORT NK_SEMI FILE.
+%fallback ID NK_BITNOT VALUES IMPORT NK_SEMI FILE.
diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c
index 522cce1fbd..26677030f4 100644
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -1673,3 +1673,13 @@ SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere) {
   }
   return (SNode*)pStmt;
 }
+
+SNode* createInsertStmt(SAstCreateContext* pCxt, SNode* pTable, SNodeList* pCols, SNode* pQuery) {
+  CHECK_PARSER_STATUS(pCxt);
+  SInsertStmt* pStmt = (SInsertStmt*)nodesMakeNode(QUERY_NODE_INSERT_STMT);
+  CHECK_OUT_OF_MEM(pStmt);
+  pStmt->pTable = pTable;
+  pStmt->pCols = pCols;
+  pStmt->pQuery = pQuery;
+  return (SNode*)pStmt;
+}
diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c
index 3ec1c2b589..f38def0b1d 100644
--- a/source/libs/parser/src/parAstParser.c
+++ b/source/libs/parser/src/parAstParser.c
@@ -451,6 +451,14 @@ static int32_t collectMetaKeyFromDelete(SCollectMetaKeyCxt* pCxt, SDeleteStmt* p
   return collectMetaKeyFromRealTableImpl(pCxt, (SRealTableNode*)pStmt->pFromTable, AUTH_TYPE_WRITE);
 }
 
+static int32_t collectMetaKeyFromInsert(SCollectMetaKeyCxt* pCxt, SInsertStmt* pStmt) {
+  int32_t code = collectMetaKeyFromRealTableImpl(pCxt, (SRealTableNode*)pStmt->pTable, AUTH_TYPE_WRITE);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = collectMetaKeyFromQuery(pCxt, pStmt->pQuery);
+  }
+  return code;
+}
+
 static int32_t collectMetaKeyFromShowBlockDist(SCollectMetaKeyCxt* pCxt, SShowTableDistributedStmt* pStmt) {
   SName name = {.type = TSDB_TABLE_NAME_T, .acctId = pCxt->pParseCxt->acctId};
   strcpy(name.dbname, pStmt->dbName);
@@ -560,6 +568,8 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) {
       return collectMetaKeyFromShowTransactions(pCxt, (SShowStmt*)pStmt);
     case QUERY_NODE_DELETE_STMT:
       return collectMetaKeyFromDelete(pCxt, (SDeleteStmt*)pStmt);
+    case QUERY_NODE_INSERT_STMT:
+      return collectMetaKeyFromInsert(pCxt, (SInsertStmt*)pStmt);
     case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:
       return collectMetaKeyFromShowBlockDist(pCxt, (SShowTableDistributedStmt*)pStmt);
     case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:
diff --git a/source/libs/parser/src/parAuthenticator.c b/source/libs/parser/src/parAuthenticator.c
index 068ac4c94d..befc822808 100644
--- a/source/libs/parser/src/parAuthenticator.c
+++ b/source/libs/parser/src/parAuthenticator.c
@@ -39,7 +39,7 @@ static int32_t checkAuth(SAuthCxt* pCxt, const char* pDbName, AUTH_TYPE type) {
   if (NULL != pCxt->pMetaCache) {
     code = getUserAuthFromCache(pCxt->pMetaCache, pParseCxt->pUser, dbFname, type, &pass);
   } else {
-    SRequestConnInfo conn = {.pTrans = pParseCxt->pTransporter, 
+    SRequestConnInfo conn = {.pTrans = pParseCxt->pTransporter,
                              .requestId = pParseCxt->requestId,
                              .requestObjRefId = pParseCxt->requestRid,
                              .mgmtEps = pParseCxt->mgmtEpSet};
@@ -88,6 +88,14 @@ static int32_t authDelete(SAuthCxt* pCxt, SDeleteStmt* pDelete) {
   return checkAuth(pCxt, ((SRealTableNode*)pDelete->pFromTable)->table.dbName, AUTH_TYPE_WRITE);
 }
 
+static int32_t authInsert(SAuthCxt* pCxt, SInsertStmt* pInsert) {
+  int32_t code = checkAuth(pCxt, ((SRealTableNode*)pInsert->pTable)->table.dbName, AUTH_TYPE_WRITE);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = authQuery(pCxt, pInsert->pQuery);
+  }
+  return code;
+}
+
 static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
   switch (nodeType(pStmt)) {
     case QUERY_NODE_SET_OPERATOR:
@@ -98,6 +106,8 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
       return authDropUser(pCxt, (SDropUserStmt*)pStmt);
     case QUERY_NODE_DELETE_STMT:
       return authDelete(pCxt, (SDeleteStmt*)pStmt);
+    case QUERY_NODE_INSERT_STMT:
+      return authInsert(pCxt, (SInsertStmt*)pStmt);
     default:
       break;
   }
diff --git a/source/libs/parser/src/parCalcConst.c b/source/libs/parser/src/parCalcConst.c
index dcdf73630f..6c670b3f01 100644
--- a/source/libs/parser/src/parCalcConst.c
+++ b/source/libs/parser/src/parCalcConst.c
@@ -300,6 +300,14 @@ static int32_t calcConstDelete(SCalcConstContext* pCxt, SDeleteStmt* pDelete) {
   return code;
 }
 
+static int32_t calcConstInsert(SCalcConstContext* pCxt, SInsertStmt* pInsert) {
+  int32_t code = calcConstFromTable(pCxt, pInsert->pTable);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = calcConstQuery(pCxt, pInsert->pQuery, false);
+  }
+  return code;
+}
+
 static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pStmt)) {
@@ -320,6 +328,9 @@ static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subque
     case QUERY_NODE_DELETE_STMT:
       code = calcConstDelete(pCxt, (SDeleteStmt*)pStmt);
       break;
+    case QUERY_NODE_INSERT_STMT:
+      code = calcConstInsert(pCxt, (SInsertStmt*)pStmt);
+      break;
     default:
       break;
   }
diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c
index a286531588..a5cf755a74 100644
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@@ -110,7 +110,7 @@ typedef struct SMemParam {
 static int32_t skipInsertInto(char** pSql, SMsgBuf* pMsg) {
   SToken sToken;
   NEXT_TOKEN(*pSql, sToken);
-  if (TK_INSERT != sToken.type) {
+  if (TK_INSERT != sToken.type && TK_IMPORT != sToken.type) {
     return buildSyntaxErrMsg(pMsg, "keyword INSERT is expected", sToken.z);
   }
   NEXT_TOKEN(*pSql, sToken);
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index f92253e8a9..d3405c5a3e 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -2839,6 +2839,21 @@ static int32_t translateDelete(STranslateContext* pCxt, SDeleteStmt* pDelete) {
   return code;
 }
 
+static int32_t translateInsert(STranslateContext* pCxt, SInsertStmt* pInsert) {
+  pCxt->pCurrStmt = (SNode*)pInsert;
+  int32_t code = translateFrom(pCxt, pInsert->pTable);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateExprList(pCxt, pInsert->pCols);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = resetTranslateNamespace(pCxt);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateQuery(pCxt, pInsert->pQuery);
+  }
+  return code;
+}
+
 static int64_t getUnitPerMinute(uint8_t precision) {
   switch (precision) {
     case TSDB_TIME_PRECISION_MILLI:
@@ -4608,6 +4623,9 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_DELETE_STMT:
       code = translateDelete(pCxt, (SDeleteStmt*)pNode);
       break;
+    case QUERY_NODE_INSERT_STMT:
+      code = translateInsert(pCxt, (SInsertStmt*)pNode);
+      break;
     case QUERY_NODE_CREATE_DATABASE_STMT:
       code = translateCreateDatabase(pCxt, (SCreateDatabaseStmt*)pNode);
       break;
@@ -6288,6 +6306,10 @@ static int32_t setQuery(STranslateContext* pCxt, SQuery* pQuery) {
       pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
       pQuery->msgType = TDMT_VND_DELETE;
       break;
+    case QUERY_NODE_INSERT_STMT:
+      pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
+      pQuery->msgType = TDMT_VND_SUBMIT;
+      break;
     case QUERY_NODE_VNODE_MODIF_STMT:
       pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
       pQuery->msgType = toMsgType(((SVnodeModifOpStmt*)pQuery->pRoot)->sqlNodeType);
diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c
index 538404798d..4f8ea00271 100644
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -19,19 +19,28 @@
 #include "parInt.h"
 #include "parToken.h"
 
-bool qIsInsertSql(const char* pStr, size_t length) {
+bool qIsInsertValuesSql(const char* pStr, size_t length) {
   if (NULL == pStr) {
     return false;
   }
 
+  const char* pSql = pStr;
+
   int32_t index = 0;
+  SToken  t = tStrGetToken((char*)pStr, &index, false);
+  if (TK_INSERT != t.type && TK_IMPORT != t.type) {
+    return false;
+  }
 
   do {
-    SToken t0 = tStrGetToken((char*)pStr, &index, false);
-    if (t0.type != TK_NK_LP) {
-      return t0.type == TK_INSERT || t0.type == TK_IMPORT;
+    pStr += index;
+    index = 0;
+    t = tStrGetToken((char*)pStr, &index, false);
+    if (TK_USING == t.type || TK_VALUES == t.type) {
+      return true;
     }
-  } while (1);
+  } while (pStr - pSql < length);
+  return false;
 }
 
 static int32_t analyseSemantic(SParseContext* pCxt, SQuery* pQuery, SParseMetaCache* pMetaCache) {
@@ -148,7 +157,7 @@ static void rewriteExprAlias(SNode* pRoot) {
 
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery) {
   int32_t code = TSDB_CODE_SUCCESS;
-  if (qIsInsertSql(pCxt->pSql, pCxt->sqlLen)) {
+  if (qIsInsertValuesSql(pCxt->pSql, pCxt->sqlLen)) {
     code = parseInsertSql(pCxt, pQuery, NULL);
   } else {
     code = parseSqlIntoAst(pCxt, pQuery);
@@ -160,7 +169,7 @@ int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery) {
 int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq) {
   SParseMetaCache metaCache = {0};
   int32_t         code = TSDB_CODE_SUCCESS;
-  if (qIsInsertSql(pCxt->pSql, pCxt->sqlLen)) {
+  if (qIsInsertValuesSql(pCxt->pSql, pCxt->sqlLen)) {
     code = parseInsertSyntax(pCxt, pQuery, &metaCache);
   } else {
     code = parseSqlSyntax(pCxt, pQuery, &metaCache);
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index fcf4d69a66..1bc204b9d9 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -139,17 +139,17 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYFALLBACK 1
-#define YYNSTATE             656
-#define YYNRULE              484
+#define YYNSTATE             661
+#define YYNRULE              485
 #define YYNTOKEN             253
-#define YY_MAX_SHIFT         655
-#define YY_MIN_SHIFTREDUCE   957
-#define YY_MAX_SHIFTREDUCE   1440
-#define YY_ERROR_ACTION      1441
-#define YY_ACCEPT_ACTION     1442
-#define YY_NO_ACTION         1443
-#define YY_MIN_REDUCE        1444
-#define YY_MAX_REDUCE        1927
+#define YY_MAX_SHIFT         660
+#define YY_MIN_SHIFTREDUCE   962
+#define YY_MAX_SHIFTREDUCE   1446
+#define YY_ERROR_ACTION      1447
+#define YY_ACCEPT_ACTION     1448
+#define YY_NO_ACTION         1449
+#define YY_MIN_REDUCE        1450
+#define YY_MAX_REDUCE        1934
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -216,664 +216,658 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (2401)
+#define YY_ACTTAB_COUNT (2363)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */    31,  256,   84,  425,  544,  426, 1479,  141, 1442, 1780,
- /*    10 */  1749, 1536,   40,   38, 1570,  117,  433,  537,  426, 1479,
- /*    20 */   334, 1746, 1242, 1571,  374, 1746,   41,   39,   37,   36,
- /*    30 */    35,  547,  120, 1317,  101, 1240,  380,  100,   99,   98,
- /*    40 */    97,   96,   95,   94,   93,   92, 1267, 1742, 1748,  323,
- /*    50 */  1267, 1742, 1748,  549,   69,  536, 1312, 1762,  507,  565,
- /*    60 */    14, 1268,   61,  565, 1377, 1905, 1248,  115,  344,   40,
- /*    70 */    38, 1380,  118,  298,  544,  520, 1574,  334,  157, 1242,
- /*    80 */  1467,  442, 1902,    1,  547, 1780,  162,  246, 1847,  543,
- /*    90 */  1317,  542, 1240,  572, 1905,  430,   11,   10, 1732, 1905,
- /*   100 */   571, 1264,  120, 1579, 1466,  652,  547,  159,  211, 1905,
- /*   110 */  1762, 1902,  157, 1312,  549, 1557, 1902,   14, 1269, 1319,
- /*   120 */  1320, 1732,  157, 1248,  339, 1793, 1902, 1624, 1626,   87,
- /*   130 */  1763,  574, 1765, 1766,  570,   60,  565,   73, 1780, 1839,
- /*   140 */     2,   60,  118,  301, 1835, 1732,  572,   43,  216, 1140,
- /*   150 */  1141, 1732,  520,  571, 1905, 1905,  546,  153, 1847, 1848,
- /*   160 */   491, 1852,  652,  111, 1243, 1631, 1241, 1904,  159,   44,
- /*   170 */   463, 1902, 1902,  489,  442,  487, 1319, 1320, 1793, 1353,
- /*   180 */  1579, 1630,  142, 1763,  574, 1765, 1766,  570, 1444,  565,
- /*   190 */  1246, 1247,  248, 1295, 1296, 1298, 1299, 1300, 1301, 1302,
- /*   200 */   567,  563, 1310, 1311, 1313, 1314, 1315, 1316, 1318, 1321,
- /*   210 */  1223, 1224,  110,  109,  108,  107,  106,  105,  104,  103,
- /*   220 */   102, 1243,  160, 1241, 1625, 1626,  550, 1919, 1401, 1905,
- /*   230 */    60, 1485,   34,   33,   60,   83,   41,   39,   37,   36,
- /*   240 */    35,   58,  158,  311,  493,   80, 1902, 1246, 1247,  228,
- /*   250 */  1295, 1296, 1298, 1299, 1300, 1301, 1302,  567,  563, 1310,
- /*   260 */  1311, 1313, 1314, 1315, 1316, 1318, 1321,   40,   38,  530,
- /*   270 */  1399, 1400, 1402, 1403,  160,  334,  140, 1242, 1456,  647,
- /*   280 */   160, 1465, 1750, 1376,  302, 1905,  160, 1007, 1317, 1006,
- /*   290 */  1240, 1266,  312, 1746,  310,  309,   69,  465,  157,   34,
- /*   300 */    33,  467, 1902,   41,   39,   37,   36,   35, 1280, 1509,
- /*   310 */   373, 1312,  372, 1905,  151,   14, 1339, 1008, 1575, 1742,
- /*   320 */  1748, 1248, 1732,  466,   40,   38, 1903, 1618,  477,  476,
- /*   330 */  1902,  565,  334,  475, 1242, 1506,  116,  472,    2,  553,
- /*   340 */   471,  470,  469,  474,  473, 1317, 1675, 1240,  295, 1098,
- /*   350 */   596,  595,  594, 1102,  593, 1104, 1105,  592, 1107,  589,
- /*   360 */   652, 1113,  586, 1115, 1116,  583,  580,  605, 1312,  160,
- /*   370 */  1340,  477,  476,  160, 1319, 1320,  475, 1464, 1248,  116,
- /*   380 */   472,  623,  621,  471,  470,  469,  129,  128,  602,  601,
- /*   390 */   600,  424,  556, 1345,  428,    8,  538,  629,  628,  627,
- /*   400 */   342, 1854,  626,  625,  624,  121,  619,  618,  617,  616,
- /*   410 */   615,  614,  613,  612,  131,  608,  321,  652, 1732, 1243,
- /*   420 */   204, 1241,   34,   33,  138, 1851,   41,   39,   37,   36,
- /*   430 */    35, 1319, 1320, 1581,   30,  332, 1334, 1335, 1336, 1337,
- /*   440 */  1338, 1342, 1343, 1344,  990, 1246, 1247, 1437, 1295, 1296,
- /*   450 */  1298, 1299, 1300, 1301, 1302,  567,  563, 1310, 1311, 1313,
- /*   460 */  1314, 1315, 1316, 1318, 1321,   34,   33,  467,  544,   41,
- /*   470 */    39,   37,   36,   35, 1631, 1854, 1243,  551, 1241,   71,
- /*   480 */   300,  322,  607,  510,  994,  995, 1463,   34,   33,  466,
- /*   490 */  1629,   41,   39,   37,   36,   35,  120, 1462, 1411, 1850,
- /*   500 */    23,  432, 1246, 1247,  428, 1295, 1296, 1298, 1299, 1300,
- /*   510 */  1301, 1302,  567,  563, 1310, 1311, 1313, 1314, 1315, 1316,
- /*   520 */  1318, 1321,   40,   38, 1322,  482,  365, 1732,  655,  544,
- /*   530 */   334, 1265, 1242,  337,  160, 1436,  118,  554, 1732,  302,
- /*   540 */   492,  138,  263, 1317, 1007, 1240, 1006,  520,  367,  363,
- /*   550 */  1581,  154, 1847, 1848,  203, 1852,  149,  120,  378,  461,
- /*   560 */  1720,  645,  641,  637,  633,  261, 1312,  533,  485,  167,
- /*   570 */   603, 1339,  479, 1622, 1008, 1579, 1248,  202,  549,   40,
- /*   580 */    38, 1762, 1266,  217,  218, 1461, 1854,  334,  508, 1242,
- /*   590 */   520,   85,  557,    9,  226,   67,  320,  118,   66, 1676,
- /*   600 */  1317,  111, 1240,   55, 1631, 1555,   54,  353,  468, 1780,
- /*   610 */  1849,  338,  246, 1847,  543,  652,  542,  572, 1579, 1905,
- /*   620 */  1629, 1060, 1732, 1312,  571, 1340, 1732,  517,   27, 1319,
- /*   630 */  1320, 1384,  157, 1248,   34,   33, 1902, 1266,   41,   39,
- /*   640 */    37,   36,   35, 1679,  300,  539,  534,  510, 1345, 1793,
- /*   650 */     9,  520, 1062,   88, 1763,  574, 1765, 1766,  570,  213,
- /*   660 */   565, 1460,  379, 1839,  607,  994,  995,  327, 1835, 1918,
- /*   670 */  1669, 1327,  652, 1674, 1243,  295, 1241, 1266, 1873, 1579,
- /*   680 */  1215,  169,  206,   37,   36,   35, 1319, 1320, 1556,   30,
- /*   690 */   332, 1334, 1335, 1336, 1337, 1338, 1342, 1343, 1344, 1459,
- /*   700 */  1246, 1247, 1732, 1295, 1296, 1298, 1299, 1300, 1301, 1302,
- /*   710 */   567,  563, 1310, 1311, 1313, 1314, 1315, 1316, 1318, 1321,
- /*   720 */  1445,   34,   33,  508, 1248,   41,   39,   37,   36,   35,
- /*   730 */  1341, 1243,  604, 1241, 1677, 1622,  268,  610,   77, 1609,
- /*   740 */  1732,  101,    7, 1458,  100,   99,   98,   97,   96,   95,
- /*   750 */    94,   93,   92, 1346, 1455, 1454, 1297, 1246, 1247, 1572,
- /*   760 */  1295, 1296, 1298, 1299, 1300, 1301, 1302,  567,  563, 1310,
- /*   770 */  1311, 1313, 1314, 1315, 1316, 1318, 1321,   40,   38,  297,
- /*   780 */   611, 1264, 1551,  605, 1732,  334,  599, 1242,  406, 1762,
- /*   790 */   520,  418, 1859, 1373,   28, 1732, 1732, 1391, 1317,  413,
- /*   800 */  1240,  383,  129,  128,  602,  601,  600,  340,  391,  520,
- /*   810 */   419, 1297,  393, 1453,  138,  138,  520, 1780, 1579, 1452,
- /*   820 */   398, 1312,  520, 1582, 1581,  572, 1451,  399,   29, 1568,
- /*   830 */  1732, 1248,  571,  441,   34,   33, 1496, 1579,   41,   39,
- /*   840 */    37,   36,   35,  384, 1579,  171,  170, 1457,    2, 1564,
- /*   850 */  1579, 1297,  500,  210, 1732,   45,    4, 1793,  478, 1566,
- /*   860 */  1732,   89, 1763,  574, 1765, 1766,  570, 1732,  565, 1450,
- /*   870 */   652, 1839, 1251,   34,   33, 1838, 1835,   41,   39,   37,
- /*   880 */    36,   35,   72,  417, 1319, 1320,  412,  411,  410,  409,
- /*   890 */   408,  405,  404,  403,  402,  401,  397,  396,  395,  394,
- /*   900 */   388,  387,  386,  385, 1449,  382,  381, 1762,  195,  197,
- /*   910 */  1732,  193,  196,  139,  520,   34,   33, 1491,  274,   41,
- /*   920 */    39,   37,   36,   35, 1373, 1576, 1562,  199, 1537, 1243,
- /*   930 */   198, 1241,  272,   57,  201, 1780,   56,  200,  207,  480,
- /*   940 */    52,  504, 1579,  548,  566, 1732,  561, 1448, 1732, 1762,
- /*   950 */   571,  598,  173,  421,  251, 1246, 1247, 1447, 1295, 1296,
- /*   960 */  1298, 1299, 1300, 1301, 1302,  567,  563, 1310, 1311, 1313,
- /*   970 */  1314, 1315, 1316, 1318, 1321, 1793,  520, 1780,   60,   88,
- /*   980 */  1763,  574, 1765, 1766,  570,  572,  565, 1708, 1732, 1839,
- /*   990 */  1732, 1489,  571,  327, 1835,  152, 1032, 1250, 1732,   11,
- /*  1000 */    10,  531,  622, 1254, 1579,  460,  549,  156,   42,  520,
- /*  1010 */   494, 1439, 1440,  483, 1781, 1865,   86, 1793, 1762,  190,
- /*  1020 */   501,   87, 1763,  574, 1765, 1766,  570, 1033,  565, 1752,
- /*  1030 */  1480, 1839, 1554,  144,  240,  301, 1835, 1579,  459,  455,
- /*  1040 */   451,  447,  189,  368,  520, 1619, 1780, 1905,  215, 1191,
- /*  1050 */   343,   64,   63,  377,  548,  505,  166,  545,  137, 1732,
- /*  1060 */   157,  571,  371, 1869, 1902,  250, 1754,  123,   70,  126,
- /*  1070 */   127,  187, 1579,   42,  520,  296, 1331,   50,  361,  245,
- /*  1080 */   359,  355,  351,  163,  346,  518, 1793,  520, 1762,  219,
- /*  1090 */    88, 1763,  574, 1765, 1766,  570,  232,  565,  519,  253,
- /*  1100 */  1839,  255, 1579,   42,  327, 1835,  152, 1242,  513,    3,
- /*  1110 */   225, 1091,   42,    5,  267, 1579, 1780,  160, 1398, 1264,
- /*  1120 */  1240,  345,  348,  352,  572,  307, 1866,  605, 1253, 1732,
- /*  1130 */  1060,  571,  578,  186,  179, 1207,  184,  235,  308,  264,
- /*  1140 */   438, 1762,  400,  520, 1347, 1671,  129,  128,  602,  601,
- /*  1150 */   600, 1248,  126, 1303,  257,  520, 1793,  168,  407,  177,
- /*  1160 */    88, 1763,  574, 1765, 1766,  570,  341,  565,  415, 1780,
- /*  1170 */  1839, 1579,  544, 1119,  327, 1835, 1918,  572,  325,  324,
- /*  1180 */   127, 1270, 1732, 1579,  571, 1896,  414,  420, 1256,  416,
- /*  1190 */   652,  422,  423, 1123,  112,  126,  431,  176, 1273, 1317,
- /*  1200 */   120, 1249,  434,  435,  178, 1762, 1272, 1274,  436, 1793,
- /*  1210 */   181,  437,  439,   88, 1763,  574, 1765, 1766,  570,  183,
- /*  1220 */   565, 1130, 1312, 1839, 1271, 1762,  440,  327, 1835, 1918,
- /*  1230 */   462,  185, 1248, 1780,   68, 1128,  130,  464, 1858,  443,
- /*  1240 */   118,  572,  188, 1713, 1569,  299, 1732,  265,  571, 1243,
- /*  1250 */   205, 1241,  192, 1780, 1565,  155, 1847, 1848,   91, 1852,
- /*  1260 */   194,  572,  549,  132,  133, 1567, 1732,  208,  571, 1563,
- /*  1270 */   495,  529,  134, 1793,  135, 1246, 1247,  281, 1763,  574,
- /*  1280 */  1765, 1766,  570,  502,  565, 1762,  212,  506,  499,  496,
- /*  1290 */   317,  528,  509, 1793,  514,  221, 1712,   89, 1763,  574,
- /*  1300 */  1765, 1766,  570, 1905,  565,  124, 1681, 1839,  511,  319,
- /*  1310 */   125,  560, 1835, 1780,  515,  516,  159,  223,  266, 1269,
- /*  1320 */  1902,  572,   76, 1580,  532,  524, 1732, 1870,  571,  230,
- /*  1330 */  1257,  541, 1252,  526,  527,  525,  326, 1880, 1762,  535,
- /*  1340 */     6,  234,  549,  523,  522, 1861, 1373,  244, 1268,  119,
- /*  1350 */   558,  242, 1762, 1793,  239,  241, 1260,  281, 1763,  574,
- /*  1360 */  1765, 1766,  570,  243,  565,  328, 1780,  563, 1310, 1311,
- /*  1370 */  1313, 1314, 1315, 1316,  569, 1879,  146, 1901, 1855, 1732,
- /*  1380 */  1780,  571,  555, 1905,   19, 1820,  249,  252,  572, 1921,
- /*  1390 */    78,  576, 1552, 1732,  269,  571,  157, 1623,  260,  648,
- /*  1400 */  1902,  145,  649,  651,   51,  552, 1793,  282,  271,  254,
- /*  1410 */   289, 1763,  574, 1765, 1766,  570,  568,  565,  562, 1811,
- /*  1420 */  1793, 1762,  292,  273,   89, 1763,  574, 1765, 1766,  570,
- /*  1430 */  1726,  565,  291, 1762, 1839,  559, 1725,   62, 1724, 1836,
- /*  1440 */   347, 1721,  350,  349, 1235, 1762, 1236,  164,  354, 1780,
- /*  1450 */  1719,  356,  357,  358,  318, 1718,  360,  572, 1717,  362,
- /*  1460 */  1716, 1780, 1732, 1715,  571,  364,  521,  366, 1698,  572,
- /*  1470 */   165,  369,  370, 1780, 1732, 1210,  571, 1209, 1692, 1691,
- /*  1480 */   375,  572,  376, 1690, 1689, 1179, 1732, 1664,  571, 1793,
- /*  1490 */  1663, 1662,   65,  290, 1763,  574, 1765, 1766,  570, 1661,
- /*  1500 */   565, 1793, 1660, 1762, 1659,  290, 1763,  574, 1765, 1766,
- /*  1510 */   570, 1658,  565, 1793, 1657,  389,  390,  285, 1763,  574,
- /*  1520 */  1765, 1766,  570, 1762,  565, 1656,  392, 1655,   34,   33,
- /*  1530 */  1654, 1780,   41,   39,   37,   36,   35, 1653, 1652,  572,
- /*  1540 */   122, 1641, 1640, 1639, 1732, 1651,  571, 1650, 1649, 1648,
- /*  1550 */  1647, 1780, 1646, 1645, 1644,  540,  331, 1643, 1642,  572,
- /*  1560 */  1638, 1637, 1636, 1635, 1732, 1634,  571, 1633, 1181, 1632,
- /*  1570 */  1510, 1793,  172, 1762, 1508,  142, 1763,  574, 1765, 1766,
- /*  1580 */   570, 1476,  565, 1475, 1706, 1762,  174,  997, 1700,  996,
- /*  1590 */   113, 1793, 1688, 1687,  114,  290, 1763,  574, 1765, 1766,
- /*  1600 */   570, 1780,  565,  182, 1280,  427, 1673,  150,  175,  569,
- /*  1610 */   180, 1558,  429, 1780, 1732, 1507,  571, 1026,  333, 1505,
- /*  1620 */  1920,  572,  444,  445,  446, 1503, 1732,  449,  571,  448,
- /*  1630 */   450, 1501,  452,  453,  454, 1499,  456, 1762,  458, 1488,
- /*  1640 */  1487, 1793, 1472,  457, 1560,  289, 1763,  574, 1765, 1766,
- /*  1650 */   570, 1134,  565, 1793, 1812, 1133, 1559,  290, 1763,  574,
- /*  1660 */  1765, 1766,  570, 1762,  565, 1780,  620, 1059,  191,   49,
- /*  1670 */   335, 1058, 1057,  572, 1497,  313, 1056,  622, 1732, 1492,
- /*  1680 */   571, 1053, 1052, 1051,  314, 1490,  315,  481, 1471,  484,
- /*  1690 */   486, 1780, 1470,  488, 1469,  490,   90, 1705, 1699,  572,
- /*  1700 */  1217,  136,  497, 1686, 1732, 1793,  571, 1684, 1685,  290,
- /*  1710 */  1763,  574, 1765, 1766,  570, 1227,  565, 1683, 1762, 1682,
- /*  1720 */  1680, 1672,  222,   53,  227,   42,   15,  209, 1258,  214,
- /*  1730 */  1762, 1793,  220,  498,   74,  275, 1763,  574, 1765, 1766,
- /*  1740 */   570,  316,  565,   75,   16,   80, 1780,   48,  238,  512,
- /*  1750 */   224,  503,   24,  229,  572, 1413,  231,  237, 1780, 1732,
- /*  1760 */   233,  571, 1752, 1425,  247, 1395,  572,   26, 1397,  143,
- /*  1770 */   236, 1732,   25,  571, 1390, 1370,   79,   47, 1751, 1369,
- /*  1780 */  1762,  147,   18, 1430, 1419, 1424, 1793,  329, 1429, 1428,
- /*  1790 */   276, 1763,  574, 1765, 1766,  570, 1762,  565, 1793,  330,
- /*  1800 */    10,   20,  277, 1763,  574, 1765, 1766,  570, 1780,  565,
- /*  1810 */  1332, 1307, 1796,  564,   32,   17,  572, 1305,  148,  161,
- /*  1820 */  1304, 1732, 1288,  571, 1780,   46,   12,   21,   22,  577,
- /*  1830 */    13,  575,  572, 1120,  336, 1117,  581, 1732,  579,  571,
- /*  1840 */   582,  584,  573, 1114,  585,  587, 1108, 1106, 1793,  588,
- /*  1850 */   590,  591,  284, 1763,  574, 1765, 1766,  570, 1762,  565,
- /*  1860 */  1097,   81,   82, 1112, 1793,  597, 1129, 1111,  286, 1763,
- /*  1870 */   574, 1765, 1766,  570,   59,  565, 1110, 1762, 1109,  258,
- /*  1880 */  1125, 1024,  606, 1048, 1066,  609, 1780,  259, 1046, 1045,
- /*  1890 */  1044, 1043, 1042, 1063,  572, 1041, 1040, 1039, 1061, 1732,
- /*  1900 */  1036,  571, 1035, 1034, 1031, 1780, 1504, 1030, 1502, 1029,
- /*  1910 */   630,  631,  634,  572, 1500,  632,  638,  635, 1732, 1762,
- /*  1920 */   571,  636,  640, 1498,  642,  639, 1793,  643, 1486,  644,
- /*  1930 */   278, 1763,  574, 1765, 1766,  570,  646,  565,  987, 1468,
- /*  1940 */   262,  650, 1443, 1443, 1244, 1793,  270, 1780,  653,  287,
- /*  1950 */  1763,  574, 1765, 1766,  570,  572,  565,  654, 1443, 1443,
- /*  1960 */  1732, 1762,  571, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  1970 */  1443, 1762, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  1980 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1793, 1443, 1780,
- /*  1990 */  1443,  279, 1763,  574, 1765, 1766,  570,  572,  565, 1780,
- /*  2000 */  1443, 1443, 1732, 1443,  571, 1443, 1443,  572, 1443, 1443,
- /*  2010 */  1443, 1443, 1732, 1443,  571, 1443, 1443, 1443, 1443, 1443,
- /*  2020 */  1443, 1443, 1443, 1762, 1443, 1443, 1443, 1443, 1443, 1793,
- /*  2030 */  1443, 1443, 1443,  288, 1763,  574, 1765, 1766,  570, 1793,
- /*  2040 */   565, 1443, 1443,  280, 1763,  574, 1765, 1766,  570, 1762,
- /*  2050 */   565, 1780, 1443, 1443, 1443, 1443, 1443, 1443, 1443,  572,
- /*  2060 */  1443, 1443, 1443, 1443, 1732, 1762,  571, 1443, 1443, 1443,
- /*  2070 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1780, 1443, 1443,
- /*  2080 */  1443, 1443, 1443, 1443, 1443,  572, 1443, 1443, 1443, 1443,
- /*  2090 */  1732, 1793,  571, 1780, 1443,  293, 1763,  574, 1765, 1766,
- /*  2100 */   570,  572,  565, 1443, 1443, 1443, 1732, 1443,  571, 1443,
- /*  2110 */  1443, 1443, 1443, 1443, 1443, 1762, 1443, 1793, 1443, 1443,
- /*  2120 */  1443,  294, 1763,  574, 1765, 1766,  570, 1762,  565, 1443,
- /*  2130 */  1443, 1443, 1443, 1793, 1443, 1443, 1443, 1774, 1763,  574,
- /*  2140 */  1765, 1766,  570, 1780,  565, 1443, 1443, 1443, 1443, 1443,
- /*  2150 */  1443,  572, 1443, 1443, 1443, 1780, 1732, 1443,  571, 1443,
- /*  2160 */  1443, 1443, 1443,  572, 1443, 1443, 1443, 1443, 1732, 1443,
- /*  2170 */   571, 1443, 1443, 1443, 1443, 1443, 1443, 1762, 1443, 1443,
- /*  2180 */  1443, 1443, 1443, 1793, 1443, 1443, 1443, 1773, 1763,  574,
- /*  2190 */  1765, 1766,  570, 1443,  565, 1793, 1443, 1443, 1443, 1772,
- /*  2200 */  1763,  574, 1765, 1766,  570, 1780,  565, 1443, 1443, 1443,
- /*  2210 */  1443, 1443, 1443,  572, 1443, 1443, 1443, 1443, 1732, 1762,
- /*  2220 */   571, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  2230 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  2240 */  1443, 1443, 1443, 1443, 1443, 1793, 1443, 1780, 1443,  305,
- /*  2250 */  1763,  574, 1765, 1766,  570,  572,  565, 1443, 1443, 1443,
- /*  2260 */  1732, 1762,  571, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  2270 */  1443, 1762, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  2280 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1793, 1443, 1780,
- /*  2290 */  1443,  304, 1763,  574, 1765, 1766,  570,  572,  565, 1780,
- /*  2300 */  1443, 1443, 1732, 1443,  571, 1443, 1443,  572, 1443, 1443,
- /*  2310 */  1443, 1443, 1732, 1443,  571, 1443, 1443, 1443, 1443, 1443,
- /*  2320 */  1443, 1762, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1793,
- /*  2330 */  1443, 1443, 1443,  306, 1763,  574, 1765, 1766,  570, 1793,
- /*  2340 */   565, 1443, 1443,  303, 1763,  574, 1765, 1766,  570, 1780,
- /*  2350 */   565, 1443, 1443, 1443, 1443, 1443, 1443,  572, 1443, 1443,
- /*  2360 */  1443, 1443, 1732, 1443,  571, 1443, 1443, 1443, 1443, 1443,
- /*  2370 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443,
- /*  2380 */  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1793,
- /*  2390 */  1443, 1443, 1443,  283, 1763,  574, 1765, 1766,  570, 1443,
- /*  2400 */   565,
+ /*     0 */   430,  549,  431, 1485,  438, 1685,  431, 1485, 1576,  549,
+ /*    10 */    34,   33,   40,   38,   41,   39,   37,   36,   35, 1753,
+ /*    20 */   337,   71, 1248, 1451,  379, 1756,  435,  342,  552,  122,
+ /*    30 */  1630, 1632, 1270, 1323,  117, 1246, 1753,  122,   41,   39,
+ /*    40 */    37,   36,   35, 1580,  103, 1749, 1755,  102,  101,  100,
+ /*    50 */    99,   98,   97,   96,   95,   94, 1318,  570,  554, 1912,
+ /*    60 */    14, 1448, 1749, 1755,  326, 1912, 1254, 1769,   62,  120,
+ /*    70 */   385, 1012, 1911, 1011,  570,  447, 1909,  120,  159,   40,
+ /*    80 */    38, 1386, 1909,    1,  156, 1854, 1855,  337, 1859, 1248,
+ /*    90 */  1273,   44,  249, 1854,  548, 1787,  547,  995,  513, 1912,
+ /*   100 */  1323, 1013, 1246,  577, 1473,  657,  323,  301, 1739, 1682,
+ /*   110 */   576,  142,  161, 1462,   61, 1912, 1909,  482,  481, 1325,
+ /*   120 */  1326,  349,  480, 1318,  554,  118,  477,   14,  160,  476,
+ /*   130 */   475,  474, 1909, 1254, 1681, 1800,  298,  999, 1000,   89,
+ /*   140 */  1770,  579, 1772, 1773,  575, 1739,  570,   61,  610, 1846,
+ /*   150 */     2,   34,   33,  304, 1842,   41,   39,   37,   36,   35,
+ /*   160 */   220,  221, 1912, 1912, 1249, 1912, 1247,  131,  130,  607,
+ /*   170 */   606,  605,  657, 1512,  552,  159, 1910, 1637,  161, 1909,
+ /*   180 */  1909,  143, 1909,  418,  325, 1542, 1325, 1326, 1450, 1145,
+ /*   190 */  1146, 1252, 1253, 1635, 1301, 1302, 1304, 1305, 1306, 1307,
+ /*   200 */  1308,  572,  568, 1316, 1317, 1319, 1320, 1321, 1322, 1324,
+ /*   210 */  1327,   61,  112,  111,  110,  109,  108,  107,  106,  105,
+ /*   220 */   104,  303,  558,  162,  515,   31,  259, 1417,  214,  174,
+ /*   230 */   173, 1249,  219, 1247,   71,  634,  633,  632,  345, 1407,
+ /*   240 */   631,  630,  629,  123,  624,  623,  622,  621,  620,  619,
+ /*   250 */   618,  617,  133,  613,  162,   61, 1581,   75, 1252, 1253,
+ /*   260 */  1273, 1301, 1302, 1304, 1305, 1306, 1307, 1308,  572,  568,
+ /*   270 */  1316, 1317, 1319, 1320, 1321, 1322, 1324, 1327,   40,   38,
+ /*   280 */   535, 1405, 1406, 1408, 1409,  549,  337,  162, 1248,  627,
+ /*   290 */   512,  378,  347,  377, 1228, 1229, 1631, 1632,  370, 1323,
+ /*   300 */  1563, 1246, 1103,  601,  600,  599, 1107,  598, 1109, 1110,
+ /*   310 */   597, 1112,  594,  122, 1118,  591, 1120, 1121,  588,  585,
+ /*   320 */   372,  368, 1318,  498,  479,  478,   14,  525, 1561,  525,
+ /*   330 */   373, 1912, 1254, 1912,  554,   40,   38, 1769,  164, 1248,
+ /*   340 */   113,   86, 1272,  337,  159, 1248,  159,  468, 1909,    2,
+ /*   350 */  1909,  162, 1246,  120,  119, 1585, 1323, 1585, 1246,  447,
+ /*   360 */   543, 1012, 1577, 1011, 1912, 1787,  207, 1472,  249, 1854,
+ /*   370 */   548,  657,  547,  577, 1787, 1912,  466,  159, 1739, 1318,
+ /*   380 */   576, 1909,  542, 1254,  552, 1325, 1326,  612,  159, 1254,
+ /*   390 */  1471, 1013, 1909,  103,  554,  162,  102,  101,  100,   99,
+ /*   400 */    98,   97,   96,   95,   94, 1800,    8, 1757, 1739,   89,
+ /*   410 */  1770,  579, 1772, 1773,  575, 1065,  570,  538, 1753, 1846,
+ /*   420 */   541,  559,  657,  304, 1842,   73,  303,  612,  657,  515,
+ /*   430 */  1249, 1739, 1247,   34,   33, 1912,  496,   41,   39,   37,
+ /*   440 */    36,   35, 1325, 1326, 1749, 1755, 1067,   43,  159,  494,
+ /*   450 */  1470,  492, 1909, 1390, 1274, 1037,  570, 1252, 1253, 1272,
+ /*   460 */  1301, 1302, 1304, 1305, 1306, 1307, 1308,  572,  568, 1316,
+ /*   470 */  1317, 1319, 1320, 1321, 1322, 1324, 1327,   11,   10,  549,
+ /*   480 */  1562, 1249,  525, 1247,  525,  549, 1038, 1249,  153, 1247,
+ /*   490 */    79, 1739, 1861,  165, 1726,  383,  544,  539,   34,   33,
+ /*   500 */   314, 1624,   41,   39,   37,   36,   35,  122, 1252, 1253,
+ /*   510 */  1585, 1578, 1585,  122, 1252, 1253, 1858, 1301, 1302, 1304,
+ /*   520 */  1305, 1306, 1307, 1308,  572,  568, 1316, 1317, 1319, 1320,
+ /*   530 */  1321, 1322, 1324, 1327,   40,   38, 1328,  525,   37,   36,
+ /*   540 */    35,  358,  337, 1769, 1248,  525,  162,  120,  384,  315,
+ /*   550 */   305,  313,  312,  120,  470, 1323,  388, 1246,  472,  324,
+ /*   560 */  1359,  551,  155, 1854, 1855, 1585, 1859,  140,  157, 1854,
+ /*   570 */  1855, 1787, 1859, 1585, 1286,  610, 1587, 1271, 1318,  553,
+ /*   580 */   471, 1443, 1345, 1333, 1739,  251,  576,  162, 1254, 1272,
+ /*   590 */    85,   40,   38, 1515,  131,  130,  607,  606,  605,  337,
+ /*   600 */    82, 1248,   34,   33, 1861,    9,   41,   39,   37,   36,
+ /*   610 */    35, 1800, 1323,  566, 1246,   90, 1770,  579, 1772, 1773,
+ /*   620 */   575,  525,  570,  429,  170, 1846,  433,  657, 1857,  330,
+ /*   630 */  1842,  154,  113,  525, 1303, 1318, 1346,   23, 1680,  473,
+ /*   640 */   298, 1325, 1326,  158,  403, 1254,  525, 1675, 1469, 1585,
+ /*   650 */    69, 1872, 1254,   68,  525,  482,  481,  404,  172, 1351,
+ /*   660 */   480, 1585,    9,  118,  477,  446, 1275,  476,  475,  474,
+ /*   670 */  1442,   34,   33,  340, 1585,   41,   39,   37,   36,   35,
+ /*   680 */  1637,  140, 1585,  525,  657,  604, 1249,  341, 1247, 1739,
+ /*   690 */  1587,  615, 1468,  616, 1582, 1557, 1635, 1383, 1325, 1326,
+ /*   700 */  1560,   30,  335, 1340, 1341, 1342, 1343, 1344, 1348, 1349,
+ /*   710 */  1350, 1585,  437, 1252, 1253,  433, 1301, 1302, 1304, 1305,
+ /*   720 */  1306, 1307, 1308,  572,  568, 1316, 1317, 1319, 1320, 1321,
+ /*   730 */  1322, 1324, 1327, 1739,   34,   33,  628,  626,   41,   39,
+ /*   740 */    37,   36,   35, 1249, 1337, 1247,   27, 1397,  608,  999,
+ /*   750 */  1000, 1628,   34,   33,  140,   29,   41,   39,   37,   36,
+ /*   760 */    35,   34,   33, 1588, 1303,   41,   39,   37,   36,   35,
+ /*   770 */  1252, 1253,   59, 1301, 1302, 1304, 1305, 1306, 1307, 1308,
+ /*   780 */   572,  568, 1316, 1317, 1319, 1320, 1321, 1322, 1324, 1327,
+ /*   790 */    40,   38,  300, 1272, 1270,  610,  660,  231,  337, 1769,
+ /*   800 */  1248,  411, 1574, 1347,  423, 1467, 1466, 1465,  525,  525,
+ /*   810 */   266, 1323, 1464, 1246,  131,  130,  607,  606,  605, 1714,
+ /*   820 */   506,  396, 1461,  424,  151,  398, 1352, 1787,    7,  650,
+ /*   830 */   646,  642,  638,  264, 1318,  577, 1585, 1585,  525, 1460,
+ /*   840 */  1739,  525,  576,  343, 1254, 1570, 1739, 1739, 1739,  510,
+ /*   850 */    42,  140,  523, 1739,  513,  609,  389,  561, 1628,   87,
+ /*   860 */  1587,    2,  229, 1739, 1861, 1683, 1585, 1800,   28, 1585,
+ /*   870 */   472,   91, 1770,  579, 1772, 1773,  575,  139,  570, 1459,
+ /*   880 */  1739, 1846, 1458,  657, 1457, 1845, 1842,  271, 1856, 1456,
+ /*   890 */  1615, 1196,  471, 1866, 1379,  522,  422, 1325, 1326,  417,
+ /*   900 */   416,  415,  414,  413,  410,  409,  408,  407,  406,  402,
+ /*   910 */   401,  400,  399,  393,  392,  391,  390, 1382,  387,  386,
+ /*   920 */  1739, 1455, 1454, 1739, 1637, 1739,  141,  216,   34,   33,
+ /*   930 */  1739,  277,   41,   39,   37,   36,   35,   45,    4, 1502,
+ /*   940 */  1636, 1572, 1249,  525, 1247,  275,   58, 1568, 1220,   57,
+ /*   950 */   209,   34,   33, 1453,  524,   41,   39,   37,   36,   35,
+ /*   960 */   210,  483, 1739, 1739, 1769,  176,  426, 1497, 1303, 1252,
+ /*   970 */  1253, 1585, 1301, 1302, 1304, 1305, 1306, 1307, 1308,  572,
+ /*   980 */   568, 1316, 1317, 1319, 1320, 1321, 1322, 1324, 1327,  485,
+ /*   990 */   198,   61, 1787,  196, 1739,  525,  200,  525,  202,  199,
+ /*  1000 */   553,  201, 1495,  305, 1286, 1739,  260,  576,  344,  556,
+ /*  1010 */   204, 1379,  218,  203,  125,  213,   52,  509,  128,  129,
+ /*  1020 */  1759,   50, 1257, 1585,  488, 1585,  235,   11,   10,   88,
+ /*  1030 */   571,  603, 1800, 1256,  505, 1345,   90, 1770,  579, 1772,
+ /*  1040 */  1773,  575, 1769,  570,   74, 1463, 1846, 1445, 1446,   42,
+ /*  1050 */   330, 1842,  154,  222, 1543,  518,  254, 1761,  562,  228,
+ /*  1060 */  1096,   42, 1404,   42,   66,   65,  382,  238,  583,  169,
+ /*  1070 */  1787,  536, 1873,  465,  499,  376,  243, 1788,  577,  128,
+ /*  1080 */   346,  129,  114, 1739, 1491,  576,  128, 1486,  299, 1346,
+ /*  1090 */  1353,  366, 1625,  364,  360,  356,  166,  351,  348, 1876,
+ /*  1100 */   550,  248, 1309,  253,  270,  256,  258,    3,   53, 1124,
+ /*  1110 */  1800,   80, 1351,    5,   90, 1770,  579, 1772, 1773,  575,
+ /*  1120 */  1128,  570, 1135, 1133, 1846,  328,  327,  132,  330, 1842,
+ /*  1130 */  1925,  162,  652,  350, 1270, 1262,  353,  357,  310, 1880,
+ /*  1140 */  1769, 1065, 1212,  311,  267,  405, 1323, 1677, 1255,  171,
+ /*  1150 */   412,  193,  419, 1260,   30,  335, 1340, 1341, 1342, 1343,
+ /*  1160 */  1344, 1348, 1349, 1350, 1259,  146, 1769,  420, 1787, 1318,
+ /*  1170 */   464,  460,  456,  452,  192, 1276,  577,  487,  421, 1254,
+ /*  1180 */   425, 1739,  427,  576,  428,  436, 1279,  439,  440,  179,
+ /*  1190 */   181, 1278,  497,  442, 1787, 1280, 1277,  441,  184,  444,
+ /*  1200 */    72,  186,  577,  190,  445,  188,  206, 1739, 1800,  576,
+ /*  1210 */    70,  448,   90, 1770,  579, 1772, 1773,  575,  534,  570,
+ /*  1220 */   490,  191, 1846,  467,  484,  469,  330, 1842, 1925,  205,
+ /*  1230 */  1575, 1719,  195, 1769, 1800, 1571,  197, 1903,   90, 1770,
+ /*  1240 */   579, 1772, 1773,  575,  134,  570,  135, 1573, 1846,   93,
+ /*  1250 */  1569,  302,  330, 1842, 1925,   56,  136,  137,   55,  268,
+ /*  1260 */   208, 1787,  501, 1865,  500,  189,  182,  504,  187,  577,
+ /*  1270 */   211,  507,  443,  511, 1739,  533,  576, 1263,  215, 1258,
+ /*  1280 */   519,  514,  320, 1718,  224, 1687, 1769,  126,  516,  127,
+ /*  1290 */   554,  180,  322,  226,  269,  520, 1769,   78, 1275,  537,
+ /*  1300 */  1586, 1800,  521,    6, 1266,  284, 1770,  579, 1772, 1773,
+ /*  1310 */   575,  233,  570,  529, 1787,  568, 1316, 1317, 1319, 1320,
+ /*  1320 */  1321, 1322,  577, 1877, 1787,  237,  531, 1739,  530,  576,
+ /*  1330 */   532, 1912,  577,  546,  329,  528,  527, 1739,  540,  576,
+ /*  1340 */   121, 1379, 1887,  554,  161,  247, 1274,  563, 1909,  560,
+ /*  1350 */  1886, 1769,   19,  581, 1800,  331, 1629,  245,  284, 1770,
+ /*  1360 */   579, 1772, 1773,  575, 1800,  570,  272, 1769,   91, 1770,
+ /*  1370 */   579, 1772, 1773,  575, 1868,  570,  246,  242, 1846, 1787,
+ /*  1380 */  1862,  244,  565, 1842, 1912, 1928, 1558,  574, 1827,  263,
+ /*  1390 */   653,  656, 1739,  252,  576, 1787,  654,  159,   51,  147,
+ /*  1400 */   285, 1909,  148,  577, 1908,  557,  295,  294, 1739,  274,
+ /*  1410 */   576,  276, 1733,  255,   63, 1732,  564, 1769,  257, 1800,
+ /*  1420 */  1731, 1730,   64,  292, 1770,  579, 1772, 1773,  575,  573,
+ /*  1430 */   570,  567, 1818, 1769,  352, 1800, 1727,  355,  354,  144,
+ /*  1440 */  1770,  579, 1772, 1773,  575, 1787,  570,  359, 1240, 1241,
+ /*  1450 */  1725,  167,  361,  577,  362,  363, 1724,  365, 1739, 1723,
+ /*  1460 */   576, 1787,  367, 1722,  369, 1721,  321,  371, 1704,  577,
+ /*  1470 */   168,  374,  375, 1215, 1739, 1769,  576, 1214, 1698, 1697,
+ /*  1480 */   380,  381, 1696,  555, 1926, 1800, 1695, 1184, 1670,   91,
+ /*  1490 */  1770,  579, 1772, 1773,  575, 1769,  570, 1669, 1668, 1846,
+ /*  1500 */    67, 1800, 1667, 1787, 1843,  293, 1770,  579, 1772, 1773,
+ /*  1510 */   575,  577,  570, 1666, 1665, 1664, 1739, 1663,  576,  394,
+ /*  1520 */   395, 1662,  397, 1787, 1661, 1660, 1659, 1658,  526, 1657,
+ /*  1530 */  1656,  577,  124, 1647, 1646, 1645, 1739, 1655,  576, 1654,
+ /*  1540 */  1653, 1652, 1651, 1800, 1650, 1649, 1648,  288, 1770,  579,
+ /*  1550 */  1772, 1773,  575, 1769,  570, 1644, 1643, 1642, 1186, 1641,
+ /*  1560 */  1640, 1639, 1638, 1800, 1516, 1769,  175,  293, 1770,  579,
+ /*  1570 */  1772, 1773,  575, 1514,  570, 1769, 1482, 1002, 1481, 1001,
+ /*  1580 */   177, 1787,  115, 1712, 1706,  545, 1694, 1693,  178,  577,
+ /*  1590 */   152,  116,  185, 1787, 1739,  432,  576,  434,  334, 1679,
+ /*  1600 */  1564,  577, 1513, 1787, 1511,  183, 1739,  449,  576,  451,
+ /*  1610 */  1509,  574,  453,  455,  450, 1031, 1739, 1507,  576,  459,
+ /*  1620 */   457, 1800,  454, 1505, 1494,  144, 1770,  579, 1772, 1773,
+ /*  1630 */   575,  461,  570, 1800, 1493, 1769,  458,  293, 1770,  579,
+ /*  1640 */  1772, 1773,  575, 1800,  570,  462,  463,  292, 1770,  579,
+ /*  1650 */  1772, 1773,  575, 1478,  570, 1566, 1819, 1139, 1769,  194,
+ /*  1660 */    49, 1138, 1565, 1787, 1064, 1063, 1062, 1061,  336,  625,
+ /*  1670 */  1927,  577, 1058, 1057, 1503, 1056, 1739, 1498,  576,  627,
+ /*  1680 */   316,  317,  486, 1496,  489,  318, 1787, 1477, 1476,  491,
+ /*  1690 */  1475,  338,  493,  495,  577,   92, 1711, 1705,  138, 1739,
+ /*  1700 */  1769,  576, 1222, 1800,  502, 1692,  212,  293, 1770,  579,
+ /*  1710 */  1772, 1773,  575, 1690,  570, 1691, 1689, 1769,   15, 1686,
+ /*  1720 */  1678,   82,   54, 1688,  225,  217, 1800,  223, 1787, 1232,
+ /*  1730 */   293, 1770,  579, 1772, 1773,  575,  577,  570,  230,  503,
+ /*  1740 */  1419, 1739,  319,  576,   76, 1787,  508,   42,   77,   16,
+ /*  1750 */   517,   24,  227,  577,  234,  232,  241, 1401, 1739,  236,
+ /*  1760 */   576, 1264, 1403,  145,   48, 1396, 1431, 1769, 1800,  239,
+ /*  1770 */   240, 1759,  278, 1770,  579, 1772, 1773,  575,   25,  570,
+ /*  1780 */    26,   81,  250, 1376, 1375, 1800,   47, 1758, 1769,  279,
+ /*  1790 */  1770,  579, 1772, 1773,  575, 1787,  570,  149, 1436,   18,
+ /*  1800 */  1430, 1425,   46,  577,  332, 1435,   17, 1434, 1739, 1769,
+ /*  1810 */   576,  333,   10, 1803,   20,  569, 1787,   13, 1338, 1313,
+ /*  1820 */   150,  163, 1311,   32,  577, 1294, 1310,  580,   12, 1739,
+ /*  1830 */    21,  576,   22,  582, 1125, 1800,  578, 1787,  584,  280,
+ /*  1840 */  1770,  579, 1772, 1773,  575,  577,  570,  339, 1122,  586,
+ /*  1850 */  1739, 1769,  576,  589,  592,  595, 1800, 1119, 1102, 1117,
+ /*  1860 */   287, 1770,  579, 1772, 1773,  575,  587,  570, 1769,  590,
+ /*  1870 */  1116, 1113,  593, 1115, 1111,  596,  602, 1800,   83, 1787,
+ /*  1880 */    84,  289, 1770,  579, 1772, 1773,  575,  577,  570, 1114,
+ /*  1890 */  1134,   60, 1739,  261,  576, 1130, 1787, 1071, 1029,  611,
+ /*  1900 */  1053,  262,  614, 1051,  577, 1050, 1049, 1048, 1046, 1739,
+ /*  1910 */  1047,  576, 1045, 1044, 1068, 1066, 1041, 1040, 1039, 1800,
+ /*  1920 */  1769,  636, 1036,  281, 1770,  579, 1772, 1773,  575, 1035,
+ /*  1930 */   570, 1034, 1510,  635,  637, 1508, 1800,  639,  640,  641,
+ /*  1940 */   290, 1770,  579, 1772, 1773,  575, 1506,  570, 1787,  643,
+ /*  1950 */   644,  645, 1504,  647,  648,  649,  577, 1492,  651,  992,
+ /*  1960 */  1474, 1739,  265,  576,  655, 1449, 1250,  273,  658,  659,
+ /*  1970 */  1449, 1449, 1449, 1449, 1769, 1449, 1449, 1449, 1449, 1449,
+ /*  1980 */  1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1800, 1449,
+ /*  1990 */  1769, 1449,  282, 1770,  579, 1772, 1773,  575, 1449,  570,
+ /*  2000 */  1769, 1449, 1787, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ /*  2010 */   577, 1449, 1449, 1449, 1449, 1739, 1449,  576, 1787, 1449,
+ /*  2020 */  1449, 1449, 1449, 1449, 1449, 1449,  577, 1449, 1787, 1449,
+ /*  2030 */  1449, 1739, 1449,  576, 1449, 1449,  577, 1449, 1449, 1449,
+ /*  2040 */  1449, 1739, 1800,  576, 1449, 1449,  291, 1770,  579, 1772,
+ /*  2050 */  1773,  575, 1769,  570, 1449, 1449, 1449, 1449, 1800, 1449,
+ /*  2060 */  1449, 1449,  283, 1770,  579, 1772, 1773,  575, 1800,  570,
+ /*  2070 */  1449, 1449,  296, 1770,  579, 1772, 1773,  575, 1449,  570,
+ /*  2080 */  1787, 1449, 1449, 1449, 1449, 1449, 1449, 1449,  577, 1449,
+ /*  2090 */  1449, 1449, 1449, 1739, 1769,  576, 1449, 1449, 1449, 1449,
+ /*  2100 */  1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1769, 1449,
+ /*  2110 */  1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1769, 1449,
+ /*  2120 */  1800, 1449, 1787, 1449,  297, 1770,  579, 1772, 1773,  575,
+ /*  2130 */   577,  570, 1449, 1449, 1449, 1739, 1787,  576, 1449, 1449,
+ /*  2140 */  1449, 1449, 1449, 1449,  577, 1449, 1787, 1449, 1449, 1739,
+ /*  2150 */  1449,  576, 1449, 1449,  577, 1449, 1449, 1449, 1449, 1739,
+ /*  2160 */  1449,  576, 1800, 1449, 1449, 1449, 1781, 1770,  579, 1772,
+ /*  2170 */  1773,  575, 1449,  570, 1449, 1449, 1800, 1769, 1449, 1449,
+ /*  2180 */  1780, 1770,  579, 1772, 1773,  575, 1800,  570, 1449, 1449,
+ /*  2190 */  1779, 1770,  579, 1772, 1773,  575, 1449,  570, 1769, 1449,
+ /*  2200 */  1449, 1449, 1449, 1449, 1449, 1787, 1449, 1449, 1449, 1449,
+ /*  2210 */  1449, 1449, 1449,  577, 1449, 1449, 1449, 1449, 1739, 1449,
+ /*  2220 */   576, 1449, 1449, 1449, 1449, 1449, 1787, 1449, 1449, 1449,
+ /*  2230 */  1449, 1449, 1449, 1449,  577, 1449, 1449, 1449, 1449, 1739,
+ /*  2240 */  1449,  576, 1449, 1449, 1449, 1800, 1449, 1449, 1449,  308,
+ /*  2250 */  1770,  579, 1772, 1773,  575, 1449,  570, 1769, 1449, 1449,
+ /*  2260 */  1449, 1449, 1449, 1449, 1449, 1449, 1800, 1769, 1449, 1449,
+ /*  2270 */   307, 1770,  579, 1772, 1773,  575, 1449,  570, 1449, 1449,
+ /*  2280 */  1449, 1449, 1449, 1769, 1449, 1787, 1449, 1449, 1449, 1449,
+ /*  2290 */  1449, 1449, 1449,  577, 1449, 1787, 1449, 1449, 1739, 1449,
+ /*  2300 */   576, 1449, 1449,  577, 1449, 1449, 1449, 1449, 1739, 1449,
+ /*  2310 */   576, 1787, 1449, 1449, 1449, 1449, 1449, 1449, 1449,  577,
+ /*  2320 */  1449, 1449, 1449, 1449, 1739, 1800,  576, 1449, 1449,  309,
+ /*  2330 */  1770,  579, 1772, 1773,  575, 1800,  570, 1449, 1449,  306,
+ /*  2340 */  1770,  579, 1772, 1773,  575, 1449,  570, 1449, 1449, 1449,
+ /*  2350 */  1449, 1800, 1449, 1449, 1449,  286, 1770,  579, 1772, 1773,
+ /*  2360 */   575, 1449,  570,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   339,  340,  266,  260,  264,  262,  263,  269,  253,  284,
- /*    10 */   286,  273,   12,   13,  286,  279,  260,  292,  262,  263,
- /*    20 */    20,  297,   22,  287,  313,  297,   12,   13,   14,   15,
- /*    30 */    16,   20,  292,   33,   21,   35,  264,   24,   25,   26,
- /*    40 */    27,   28,   29,   30,   31,   32,   20,  323,  324,  325,
- /*    50 */    20,  323,  324,  313,  268,  330,   56,  256,  313,  335,
- /*    60 */    60,   20,    4,  335,    4,  354,   66,  281,  313,   12,
- /*    70 */    13,   14,  332,  301,  264,  264,  290,   20,  367,   22,
- /*    80 */   256,   59,  371,   83,   20,  284,  275,  347,  348,  349,
- /*    90 */    33,  351,   35,  292,  354,   14,    1,    2,  297,  354,
- /*   100 */   299,   20,  292,  292,  256,  105,   20,  367,   56,  354,
- /*   110 */   256,  371,  367,   56,  313,    0,  371,   60,   20,  119,
- /*   120 */   120,  297,  367,   66,  295,  324,  371,  298,  299,  328,
- /*   130 */   329,  330,  331,  332,  333,   83,  335,   85,  284,  338,
- /*   140 */    83,   83,  332,  342,  343,  297,  292,   83,  114,  119,
- /*   150 */   120,  297,  264,  299,  354,  354,  346,  347,  348,  349,
- /*   160 */    21,  351,  105,  275,  164,  284,  166,  367,  367,   83,
- /*   170 */   282,  371,  371,   34,   59,   36,  119,  120,  324,   84,
- /*   180 */   292,  300,  328,  329,  330,  331,  332,  333,    0,  335,
- /*   190 */   190,  191,  151,  193,  194,  195,  196,  197,  198,  199,
+ /*     0 */   260,  264,  262,  263,  260,    0,  262,  263,  286,  264,
+ /*    10 */     8,    9,   12,   13,   12,   13,   14,   15,   16,  297,
+ /*    20 */    20,  268,   22,    0,  313,  286,   14,  295,   20,  292,
+ /*    30 */   298,  299,   20,   33,  281,   35,  297,  292,   12,   13,
+ /*    40 */    14,   15,   16,  290,   21,  323,  324,   24,   25,   26,
+ /*    50 */    27,   28,   29,   30,   31,   32,   56,  335,  313,  354,
+ /*    60 */    60,  253,  323,  324,  325,  354,   66,  256,    4,  332,
+ /*    70 */   264,   20,  367,   22,  335,   59,  371,  332,  367,   12,
+ /*    80 */    13,   14,  371,   83,  347,  348,  349,   20,  351,   22,
+ /*    90 */    20,   83,  347,  348,  349,  284,  351,    4,  299,  354,
+ /*   100 */    33,   50,   35,  292,  256,  105,  307,  301,  297,  310,
+ /*   110 */   299,  255,  367,  257,   83,  354,  371,   62,   63,  119,
+ /*   120 */   120,  313,   67,   56,  313,   70,   71,   60,  367,   74,
+ /*   130 */    75,   76,  371,   66,  309,  324,  311,   44,   45,  328,
+ /*   140 */   329,  330,  331,  332,  333,  297,  335,   83,   95,  338,
+ /*   150 */    83,    8,    9,  342,  343,   12,   13,   14,   15,   16,
+ /*   160 */   114,  115,  354,  354,  164,  354,  166,  114,  115,  116,
+ /*   170 */   117,  118,  105,    0,   20,  367,  367,  284,  367,  371,
+ /*   180 */   371,  269,  371,   77,  291,  273,  119,  120,    0,  119,
+ /*   190 */   120,  191,  192,  300,  194,  195,  196,  197,  198,  199,
  /*   200 */   200,  201,  202,  203,  204,  205,  206,  207,  208,  209,
- /*   210 */   176,  177,   24,   25,   26,   27,   28,   29,   30,   31,
- /*   220 */    32,  164,  222,  166,  298,  299,  372,  373,  190,  354,
- /*   230 */    83,    0,    8,    9,   83,   83,   12,   13,   14,   15,
- /*   240 */    16,    3,  367,   37,  313,   93,  371,  190,  191,  151,
- /*   250 */   193,  194,  195,  196,  197,  198,  199,  200,  201,  202,
- /*   260 */   203,  204,  205,  206,  207,  208,  209,   12,   13,  231,
- /*   270 */   232,  233,  234,  235,  222,   20,  255,   22,  257,   48,
- /*   280 */   222,  256,  286,  223,   60,  354,  222,   20,   33,   22,
- /*   290 */    35,   20,   86,  297,   88,   89,  268,   91,  367,    8,
- /*   300 */     9,   95,  371,   12,   13,   14,   15,   16,   84,    0,
- /*   310 */   163,   56,  165,  354,  283,   60,   92,   50,  290,  323,
- /*   320 */   324,   66,  297,  117,   12,   13,  367,  296,   62,   63,
- /*   330 */   371,  335,   20,   67,   22,    0,   70,   71,   83,   43,
- /*   340 */    74,   75,   76,  270,  271,   33,  309,   35,  311,   96,
- /*   350 */    97,   98,   99,  100,  101,  102,  103,  104,  105,  106,
- /*   360 */   105,  108,  109,  110,  111,  112,  113,   95,   56,  222,
- /*   370 */   146,   62,   63,  222,  119,  120,   67,  256,   66,   70,
- /*   380 */    71,  270,  271,   74,   75,   76,  114,  115,  116,  117,
- /*   390 */   118,  261,   43,  169,  264,   83,   20,   62,   63,   64,
- /*   400 */    65,  326,   67,   68,   69,   70,   71,   72,   73,   74,
- /*   410 */    75,   76,   77,   78,   79,   80,  276,  105,  297,  164,
- /*   420 */   115,  166,    8,    9,  284,  350,   12,   13,   14,   15,
- /*   430 */    16,  119,  120,  293,  210,  211,  212,  213,  214,  215,
- /*   440 */   216,  217,  218,  219,    4,  190,  191,  156,  193,  194,
- /*   450 */   195,  196,  197,  198,  199,  200,  201,  202,  203,  204,
- /*   460 */   205,  206,  207,  208,  209,    8,    9,   95,  264,   12,
- /*   470 */    13,   14,   15,   16,  284,  326,  164,  239,  166,  174,
- /*   480 */   175,  291,   59,  178,   44,   45,  256,    8,    9,  117,
- /*   490 */   300,   12,   13,   14,   15,   16,  292,  256,   84,  350,
- /*   500 */    43,  261,  190,  191,  264,  193,  194,  195,  196,  197,
- /*   510 */   198,  199,  200,  201,  202,  203,  204,  205,  206,  207,
- /*   520 */   208,  209,   12,   13,   14,    4,  159,  297,   19,  264,
- /*   530 */    20,   20,   22,  276,  222,  244,  332,  241,  297,   60,
- /*   540 */    19,  284,   33,   33,   20,   35,   22,  264,  181,  182,
- /*   550 */   293,  347,  348,  349,   33,  351,   47,  292,  275,   35,
- /*   560 */     0,   52,   53,   54,   55,   56,   56,  149,   47,   56,
- /*   570 */   294,   92,   51,  297,   50,  292,   66,   56,  313,   12,
- /*   580 */    13,  256,   20,  114,  115,  256,  326,   20,  299,   22,
- /*   590 */   264,   82,  243,   83,   85,   82,  307,  332,   85,  310,
- /*   600 */    33,  275,   35,   82,  284,    0,   85,   47,  282,  284,
- /*   610 */   350,  291,  347,  348,  349,  105,  351,  292,  292,  354,
- /*   620 */   300,   35,  297,   56,  299,  146,  297,  118,    2,  119,
- /*   630 */   120,   14,  367,   66,    8,    9,  371,   20,   12,   13,
- /*   640 */    14,   15,   16,    0,  175,  227,  228,  178,  169,  324,
- /*   650 */    83,  264,   66,  328,  329,  330,  331,  332,  333,  150,
- /*   660 */   335,  256,  275,  338,   59,   44,   45,  342,  343,  344,
- /*   670 */   292,   14,  105,  309,  164,  311,  166,   20,  353,  292,
- /*   680 */   171,  303,  173,   14,   15,   16,  119,  120,    0,  210,
- /*   690 */   211,  212,  213,  214,  215,  216,  217,  218,  219,  256,
- /*   700 */   190,  191,  297,  193,  194,  195,  196,  197,  198,  199,
- /*   710 */   200,  201,  202,  203,  204,  205,  206,  207,  208,  209,
- /*   720 */     0,    8,    9,  299,   66,   12,   13,   14,   15,   16,
- /*   730 */   146,  164,  294,  166,  310,  297,  277,   66,  266,  280,
- /*   740 */   297,   21,   39,  256,   24,   25,   26,   27,   28,   29,
- /*   750 */    30,   31,   32,  169,  256,  256,  194,  190,  191,  287,
- /*   760 */   193,  194,  195,  196,  197,  198,  199,  200,  201,  202,
- /*   770 */   203,  204,  205,  206,  207,  208,  209,   12,   13,   18,
- /*   780 */   272,   20,  274,   95,  297,   20,   94,   22,   27,  256,
- /*   790 */   264,   30,  220,  221,  210,  297,  297,   84,   33,   77,
- /*   800 */    35,  275,  114,  115,  116,  117,  118,  276,   47,  264,
- /*   810 */    49,  194,   51,  256,  284,  284,  264,  284,  292,  256,
- /*   820 */   275,   56,  264,  293,  293,  292,  256,  275,    2,  285,
- /*   830 */   297,   66,  299,  275,    8,    9,    0,  292,   12,   13,
- /*   840 */    14,   15,   16,   82,  292,  123,  124,  257,   83,  285,
- /*   850 */   292,  194,  317,   56,  297,   42,   43,  324,   22,  285,
- /*   860 */   297,  328,  329,  330,  331,  332,  333,  297,  335,  256,
- /*   870 */   105,  338,   35,    8,    9,  342,  343,   12,   13,   14,
- /*   880 */    15,   16,   85,  122,  119,  120,  125,  126,  127,  128,
- /*   890 */   129,  130,  131,  132,  133,  134,  135,  136,  137,  138,
- /*   900 */   139,  140,  141,  142,  256,  144,  145,  256,   87,   87,
- /*   910 */   297,   90,   90,   18,  264,    8,    9,    0,   23,   12,
- /*   920 */    13,   14,   15,   16,  221,  275,  285,   87,  273,  164,
- /*   930 */    90,  166,   37,   38,   87,  284,   41,   90,  285,   22,
- /*   940 */   151,  152,  292,  292,  285,  297,   60,  256,  297,  256,
- /*   950 */   299,  285,   57,   58,  374,  190,  191,  256,  193,  194,
- /*   960 */   195,  196,  197,  198,  199,  200,  201,  202,  203,  204,
- /*   970 */   205,  206,  207,  208,  209,  324,  264,  284,   83,  328,
- /*   980 */   329,  330,  331,  332,  333,  292,  335,  275,  297,  338,
- /*   990 */   297,    0,  299,  342,  343,  344,   35,   35,  297,    1,
- /*  1000 */     2,  365,   43,  166,  292,  265,  313,  356,   43,  264,
- /*  1010 */   320,  119,  120,   22,  284,  364,  121,  324,  256,   33,
- /*  1020 */   275,  328,  329,  330,  331,  332,  333,   66,  335,   46,
- /*  1030 */   263,  338,    0,   47,  361,  342,  343,  292,   52,   53,
- /*  1040 */    54,   55,   56,   84,  264,  296,  284,  354,   43,   84,
- /*  1050 */   265,  156,  157,  158,  292,  275,  161,  352,  151,  297,
- /*  1060 */   367,  299,  167,  327,  371,  368,   83,   43,   82,   43,
- /*  1070 */    43,   85,  292,   43,  264,  180,  190,   43,  183,  345,
- /*  1080 */   185,  186,  187,  188,  189,  275,  324,  264,  256,   84,
- /*  1090 */   328,  329,  330,  331,  332,  333,   43,  335,  275,  368,
- /*  1100 */   338,  368,  292,   43,  342,  343,  344,   22,   84,  355,
- /*  1110 */    84,   84,   43,  224,   84,  292,  284,  222,   84,   20,
- /*  1120 */    35,  322,  264,   47,  292,  321,  364,   95,  166,  297,
- /*  1130 */    35,  299,   43,  147,  148,  162,  150,   84,  270,  315,
- /*  1140 */   154,  256,  264,  264,   84,  264,  114,  115,  116,  117,
- /*  1150 */   118,   66,   43,   84,  275,  264,  324,   42,  304,  173,
- /*  1160 */   328,  329,  330,  331,  332,  333,  275,  335,  146,  284,
- /*  1170 */   338,  292,  264,   84,  342,  343,  344,  292,   12,   13,
- /*  1180 */    43,   20,  297,  292,  299,  353,  302,  264,   22,  302,
- /*  1190 */   105,  264,  258,   84,   43,   43,  258,  268,   20,   33,
- /*  1200 */   292,   35,  319,  299,  268,  256,   20,   20,  312,  324,
- /*  1210 */   268,  314,  312,  328,  329,  330,  331,  332,  333,  268,
- /*  1220 */   335,   84,   56,  338,   20,  256,  305,  342,  343,  344,
- /*  1230 */   258,  268,   66,  284,  268,   84,   84,  284,  353,  264,
- /*  1240 */   332,  292,  268,  297,  284,  258,  297,  319,  299,  164,
- /*  1250 */   266,  166,  284,  284,  284,  347,  348,  349,  264,  351,
- /*  1260 */   284,  292,  313,  284,  284,  284,  297,  266,  299,  284,
- /*  1270 */   172,  105,  284,  324,  284,  190,  191,  328,  329,  330,
- /*  1280 */   331,  332,  333,  264,  335,  256,  266,  264,  299,  318,
- /*  1290 */   312,  229,  297,  324,  148,  292,  297,  328,  329,  330,
- /*  1300 */   331,  332,  333,  354,  335,  308,  297,  338,  297,  297,
- /*  1310 */   308,  342,  343,  284,  306,  305,  367,  266,  280,   20,
- /*  1320 */   371,  292,  266,  292,  230,  297,  297,  327,  299,  308,
- /*  1330 */   164,  155,  166,  297,  297,  238,  297,  360,  256,  297,
- /*  1340 */   236,  308,  313,  237,  225,  363,  221,  322,   20,  292,
- /*  1350 */   242,  358,  256,  324,  362,  359,  190,  328,  329,  330,
- /*  1360 */   331,  332,  333,  357,  335,  245,  284,  201,  202,  203,
- /*  1370 */   204,  205,  206,  207,  292,  360,  360,  370,  326,  297,
- /*  1380 */   284,  299,  240,  354,   83,  341,  369,  369,  292,  375,
- /*  1390 */    83,  288,  274,  297,  264,  299,  367,  297,  266,   36,
- /*  1400 */   371,  311,  259,  258,  316,  370,  324,  278,  267,  369,
- /*  1410 */   328,  329,  330,  331,  332,  333,  334,  335,  336,  337,
- /*  1420 */   324,  256,  278,  254,  328,  329,  330,  331,  332,  333,
- /*  1430 */     0,  335,  278,  256,  338,  370,    0,   42,    0,  343,
- /*  1440 */    74,    0,  184,   35,   35,  256,   35,   35,  184,  284,
- /*  1450 */     0,   35,   35,  184,  289,    0,  184,  292,    0,   35,
- /*  1460 */     0,  284,  297,    0,  299,   22,  289,   35,    0,  292,
- /*  1470 */    83,  169,  168,  284,  297,  166,  299,  164,    0,    0,
- /*  1480 */   160,  292,  159,    0,    0,   46,  297,    0,  299,  324,
- /*  1490 */     0,    0,  143,  328,  329,  330,  331,  332,  333,    0,
- /*  1500 */   335,  324,    0,  256,    0,  328,  329,  330,  331,  332,
- /*  1510 */   333,    0,  335,  324,    0,  138,   35,  328,  329,  330,
- /*  1520 */   331,  332,  333,  256,  335,    0,  138,    0,    8,    9,
- /*  1530 */     0,  284,   12,   13,   14,   15,   16,    0,    0,  292,
- /*  1540 */    42,    0,    0,    0,  297,    0,  299,    0,    0,    0,
- /*  1550 */     0,  284,    0,    0,    0,  366,  289,    0,    0,  292,
- /*  1560 */     0,    0,    0,    0,  297,    0,  299,    0,   22,    0,
- /*  1570 */     0,  324,   56,  256,    0,  328,  329,  330,  331,  332,
- /*  1580 */   333,    0,  335,    0,    0,  256,   42,   14,    0,   14,
- /*  1590 */    39,  324,    0,    0,   39,  328,  329,  330,  331,  332,
- /*  1600 */   333,  284,  335,  155,   84,   46,    0,   43,   40,  292,
- /*  1610 */    39,    0,   46,  284,  297,    0,  299,   61,  289,    0,
- /*  1620 */   373,  292,   35,   47,   39,    0,  297,   47,  299,   35,
- /*  1630 */    39,    0,   35,   47,   39,    0,   35,  256,   39,    0,
- /*  1640 */     0,  324,    0,   47,    0,  328,  329,  330,  331,  332,
- /*  1650 */   333,   35,  335,  324,  337,   22,    0,  328,  329,  330,
- /*  1660 */   331,  332,  333,  256,  335,  284,   43,   35,   90,   92,
- /*  1670 */   289,   35,   35,  292,    0,   22,   35,   43,  297,    0,
- /*  1680 */   299,   35,   35,   35,   22,    0,   22,   49,    0,   35,
- /*  1690 */    35,  284,    0,   35,    0,   22,   20,    0,    0,  292,
- /*  1700 */    35,  170,   22,    0,  297,  324,  299,    0,    0,  328,
- /*  1710 */   329,  330,  331,  332,  333,  179,  335,    0,  256,    0,
- /*  1720 */     0,    0,   39,  151,   46,   43,   83,  148,   22,   84,
- /*  1730 */   256,  324,   83,  151,   83,  328,  329,  330,  331,  332,
- /*  1740 */   333,  151,  335,   83,  226,   93,  284,   43,   46,  149,
- /*  1750 */   147,  153,   83,   83,  292,   84,   84,   43,  284,  297,
- /*  1760 */    83,  299,   46,   35,   46,   84,  292,   43,   84,   83,
- /*  1770 */    83,  297,   83,  299,   84,   84,   83,   43,   46,   84,
- /*  1780 */   256,   46,   43,   84,   84,   35,  324,   35,   35,   35,
- /*  1790 */   328,  329,  330,  331,  332,  333,  256,  335,  324,   35,
- /*  1800 */     2,   43,  328,  329,  330,  331,  332,  333,  284,  335,
- /*  1810 */   190,   84,   83,   83,   83,  226,  292,   84,   46,   46,
- /*  1820 */    84,  297,   22,  299,  284,  220,   83,   83,   83,   35,
- /*  1830 */   226,   94,  292,   84,   35,   84,   35,  297,   83,  299,
- /*  1840 */    83,   35,  192,   84,   83,   35,   84,   84,  324,   83,
- /*  1850 */    35,   83,  328,  329,  330,  331,  332,  333,  256,  335,
- /*  1860 */    22,   83,   83,  107,  324,   95,   35,  107,  328,  329,
- /*  1870 */   330,  331,  332,  333,   83,  335,  107,  256,  107,   43,
- /*  1880 */    22,   61,   60,   35,   66,   81,  284,   43,   35,   35,
- /*  1890 */    35,   35,   35,   66,  292,   22,   35,   35,   35,  297,
- /*  1900 */    35,  299,   35,   35,   35,  284,    0,   35,    0,   35,
- /*  1910 */    35,   47,   35,  292,    0,   39,   35,   47,  297,  256,
- /*  1920 */   299,   39,   39,    0,   35,   47,  324,   47,    0,   39,
- /*  1930 */   328,  329,  330,  331,  332,  333,   35,  335,   35,    0,
- /*  1940 */    22,   21,  376,  376,   22,  324,   22,  284,   21,  328,
- /*  1950 */   329,  330,  331,  332,  333,  292,  335,   20,  376,  376,
- /*  1960 */   297,  256,  299,  376,  376,  376,  376,  376,  376,  376,
- /*  1970 */   376,  256,  376,  376,  376,  376,  376,  376,  376,  376,
- /*  1980 */   376,  376,  376,  376,  376,  376,  376,  324,  376,  284,
- /*  1990 */   376,  328,  329,  330,  331,  332,  333,  292,  335,  284,
- /*  2000 */   376,  376,  297,  376,  299,  376,  376,  292,  376,  376,
- /*  2010 */   376,  376,  297,  376,  299,  376,  376,  376,  376,  376,
- /*  2020 */   376,  376,  376,  256,  376,  376,  376,  376,  376,  324,
- /*  2030 */   376,  376,  376,  328,  329,  330,  331,  332,  333,  324,
- /*  2040 */   335,  376,  376,  328,  329,  330,  331,  332,  333,  256,
- /*  2050 */   335,  284,  376,  376,  376,  376,  376,  376,  376,  292,
- /*  2060 */   376,  376,  376,  376,  297,  256,  299,  376,  376,  376,
- /*  2070 */   376,  376,  376,  376,  376,  376,  376,  284,  376,  376,
- /*  2080 */   376,  376,  376,  376,  376,  292,  376,  376,  376,  376,
- /*  2090 */   297,  324,  299,  284,  376,  328,  329,  330,  331,  332,
- /*  2100 */   333,  292,  335,  376,  376,  376,  297,  376,  299,  376,
- /*  2110 */   376,  376,  376,  376,  376,  256,  376,  324,  376,  376,
- /*  2120 */   376,  328,  329,  330,  331,  332,  333,  256,  335,  376,
- /*  2130 */   376,  376,  376,  324,  376,  376,  376,  328,  329,  330,
- /*  2140 */   331,  332,  333,  284,  335,  376,  376,  376,  376,  376,
- /*  2150 */   376,  292,  376,  376,  376,  284,  297,  376,  299,  376,
- /*  2160 */   376,  376,  376,  292,  376,  376,  376,  376,  297,  376,
- /*  2170 */   299,  376,  376,  376,  376,  376,  376,  256,  376,  376,
- /*  2180 */   376,  376,  376,  324,  376,  376,  376,  328,  329,  330,
- /*  2190 */   331,  332,  333,  376,  335,  324,  376,  376,  376,  328,
- /*  2200 */   329,  330,  331,  332,  333,  284,  335,  376,  376,  376,
- /*  2210 */   376,  376,  376,  292,  376,  376,  376,  376,  297,  256,
- /*  2220 */   299,  376,  376,  376,  376,  376,  376,  376,  376,  376,
- /*  2230 */   376,  376,  376,  376,  376,  376,  376,  376,  376,  376,
- /*  2240 */   376,  376,  376,  376,  376,  324,  376,  284,  376,  328,
- /*  2250 */   329,  330,  331,  332,  333,  292,  335,  376,  376,  376,
- /*  2260 */   297,  256,  299,  376,  376,  376,  376,  376,  376,  376,
- /*  2270 */   376,  256,  376,  376,  376,  376,  376,  376,  376,  376,
- /*  2280 */   376,  376,  376,  376,  376,  376,  376,  324,  376,  284,
- /*  2290 */   376,  328,  329,  330,  331,  332,  333,  292,  335,  284,
- /*  2300 */   376,  376,  297,  376,  299,  376,  376,  292,  376,  376,
- /*  2310 */   376,  376,  297,  376,  299,  376,  376,  376,  376,  376,
- /*  2320 */   376,  256,  376,  376,  376,  376,  376,  376,  376,  324,
- /*  2330 */   376,  376,  376,  328,  329,  330,  331,  332,  333,  324,
- /*  2340 */   335,  376,  376,  328,  329,  330,  331,  332,  333,  284,
- /*  2350 */   335,  376,  376,  376,  376,  376,  376,  292,  376,  376,
- /*  2360 */   376,  376,  297,  376,  299,  376,  376,  376,  376,  376,
- /*  2370 */   376,  376,  376,  376,  376,  376,  376,  376,  376,  376,
- /*  2380 */   376,  376,  376,  376,  376,  376,  376,  376,  376,  324,
- /*  2390 */   376,  376,  376,  328,  329,  330,  331,  332,  333,  376,
- /*  2400 */   335,
+ /*   210 */   210,   83,   24,   25,   26,   27,   28,   29,   30,   31,
+ /*   220 */    32,  175,   43,  223,  178,  339,  340,   84,   56,  123,
+ /*   230 */   124,  164,  114,  166,  268,   62,   63,   64,   65,  191,
+ /*   240 */    67,   68,   69,   70,   71,   72,   73,   74,   75,   76,
+ /*   250 */    77,   78,   79,   80,  223,   83,  290,   85,  191,  192,
+ /*   260 */    20,  194,  195,  196,  197,  198,  199,  200,  201,  202,
+ /*   270 */   203,  204,  205,  206,  207,  208,  209,  210,   12,   13,
+ /*   280 */   232,  233,  234,  235,  236,  264,   20,  223,   22,   43,
+ /*   290 */   313,  163,  313,  165,  176,  177,  298,  299,  159,   33,
+ /*   300 */     0,   35,   96,   97,   98,   99,  100,  101,  102,  103,
+ /*   310 */   104,  105,  106,  292,  108,  109,  110,  111,  112,  113,
+ /*   320 */   181,  182,   56,  313,  270,  271,   60,  264,    0,  264,
+ /*   330 */    84,  354,   66,  354,  313,   12,   13,  256,  275,   22,
+ /*   340 */   275,  266,   20,   20,  367,   22,  367,  282,  371,   83,
+ /*   350 */   371,  223,   35,  332,  279,  292,   33,  292,   35,   59,
+ /*   360 */    20,   20,  287,   22,  354,  284,  115,  256,  347,  348,
+ /*   370 */   349,  105,  351,  292,  284,  354,   35,  367,  297,   56,
+ /*   380 */   299,  371,  292,   66,   20,  119,  120,   59,  367,   66,
+ /*   390 */   256,   50,  371,   21,  313,  223,   24,   25,   26,   27,
+ /*   400 */    28,   29,   30,   31,   32,  324,   83,  286,  297,  328,
+ /*   410 */   329,  330,  331,  332,  333,   35,  335,  149,  297,  338,
+ /*   420 */   330,  242,  105,  342,  343,  174,  175,   59,  105,  178,
+ /*   430 */   164,  297,  166,    8,    9,  354,   21,   12,   13,   14,
+ /*   440 */    15,   16,  119,  120,  323,  324,   66,   83,  367,   34,
+ /*   450 */   256,   36,  371,   14,   20,   35,  335,  191,  192,   20,
+ /*   460 */   194,  195,  196,  197,  198,  199,  200,  201,  202,  203,
+ /*   470 */   204,  205,  206,  207,  208,  209,  210,    1,    2,  264,
+ /*   480 */     0,  164,  264,  166,  264,  264,   66,  164,  283,  166,
+ /*   490 */   266,  297,  326,  275,    0,  275,  228,  229,    8,    9,
+ /*   500 */    37,  296,   12,   13,   14,   15,   16,  292,  191,  192,
+ /*   510 */   292,  287,  292,  292,  191,  192,  350,  194,  195,  196,
+ /*   520 */   197,  198,  199,  200,  201,  202,  203,  204,  205,  206,
+ /*   530 */   207,  208,  209,  210,   12,   13,   14,  264,   14,   15,
+ /*   540 */    16,   47,   20,  256,   22,  264,  223,  332,  275,   86,
+ /*   550 */    60,   88,   89,  332,   91,   33,  275,   35,   95,  276,
+ /*   560 */    84,  346,  347,  348,  349,  292,  351,  284,  347,  348,
+ /*   570 */   349,  284,  351,  292,   84,   95,  293,   20,   56,  292,
+ /*   580 */   117,  156,   92,   14,  297,  151,  299,  223,   66,   20,
+ /*   590 */    83,   12,   13,    0,  114,  115,  116,  117,  118,   20,
+ /*   600 */    93,   22,    8,    9,  326,   83,   12,   13,   14,   15,
+ /*   610 */    16,  324,   33,   60,   35,  328,  329,  330,  331,  332,
+ /*   620 */   333,  264,  335,  261,   56,  338,  264,  105,  350,  342,
+ /*   630 */   343,  344,  275,  264,  195,   56,  146,   43,  309,  282,
+ /*   640 */   311,  119,  120,  356,  275,   66,  264,  292,  256,  292,
+ /*   650 */    82,  364,   66,   85,  264,   62,   63,  275,  303,  169,
+ /*   660 */    67,  292,   83,   70,   71,  275,   20,   74,   75,   76,
+ /*   670 */   245,    8,    9,  276,  292,   12,   13,   14,   15,   16,
+ /*   680 */   284,  284,  292,  264,  105,   94,  164,  291,  166,  297,
+ /*   690 */   293,   66,  256,  272,  275,  274,  300,    4,  119,  120,
+ /*   700 */     0,  211,  212,  213,  214,  215,  216,  217,  218,  219,
+ /*   710 */   220,  292,  261,  191,  192,  264,  194,  195,  196,  197,
+ /*   720 */   198,  199,  200,  201,  202,  203,  204,  205,  206,  207,
+ /*   730 */   208,  209,  210,  297,    8,    9,  270,  271,   12,   13,
+ /*   740 */    14,   15,   16,  164,  191,  166,    2,   84,  294,   44,
+ /*   750 */    45,  297,    8,    9,  284,    2,   12,   13,   14,   15,
+ /*   760 */    16,    8,    9,  293,  195,   12,   13,   14,   15,   16,
+ /*   770 */   191,  192,    3,  194,  195,  196,  197,  198,  199,  200,
+ /*   780 */   201,  202,  203,  204,  205,  206,  207,  208,  209,  210,
+ /*   790 */    12,   13,   18,   20,   20,   95,   19,  151,   20,  256,
+ /*   800 */    22,   27,  285,  146,   30,  256,  256,  256,  264,  264,
+ /*   810 */    33,   33,  256,   35,  114,  115,  116,  117,  118,  275,
+ /*   820 */   275,   47,  256,   49,   47,   51,  169,  284,   39,   52,
+ /*   830 */    53,   54,   55,   56,   56,  292,  292,  292,  264,  256,
+ /*   840 */   297,  264,  299,  276,   66,  285,  297,  297,  297,  275,
+ /*   850 */    43,  284,  275,  297,  299,  294,   82,   43,  297,   82,
+ /*   860 */   293,   83,   85,  297,  326,  310,  292,  324,  211,  292,
+ /*   870 */    95,  328,  329,  330,  331,  332,  333,  151,  335,  256,
+ /*   880 */   297,  338,  256,  105,  256,  342,  343,  277,  350,  256,
+ /*   890 */   280,   84,  117,  221,  222,  118,  122,  119,  120,  125,
+ /*   900 */   126,  127,  128,  129,  130,  131,  132,  133,  134,  135,
+ /*   910 */   136,  137,  138,  139,  140,  141,  142,  224,  144,  145,
+ /*   920 */   297,  256,  256,  297,  284,  297,   18,  150,    8,    9,
+ /*   930 */   297,   23,   12,   13,   14,   15,   16,   42,   43,    0,
+ /*   940 */   300,  285,  164,  264,  166,   37,   38,  285,  171,   41,
+ /*   950 */   173,    8,    9,  256,  275,   12,   13,   14,   15,   16,
+ /*   960 */   285,   22,  297,  297,  256,   57,   58,    0,  195,  191,
+ /*   970 */   192,  292,  194,  195,  196,  197,  198,  199,  200,  201,
+ /*   980 */   202,  203,  204,  205,  206,  207,  208,  209,  210,   22,
+ /*   990 */    87,   83,  284,   90,  297,  264,   87,  264,   87,   90,
+ /*  1000 */   292,   90,    0,   60,   84,  297,  275,  299,  275,  240,
+ /*  1010 */    87,  222,   43,   90,   43,   56,  151,  152,   43,   43,
+ /*  1020 */    46,   43,   35,  292,   22,  292,   43,    1,    2,  121,
+ /*  1030 */   285,  285,  324,   35,  317,   92,  328,  329,  330,  331,
+ /*  1040 */   332,  333,  256,  335,   85,  257,  338,  119,  120,   43,
+ /*  1050 */   342,  343,  344,   84,  273,   84,  374,   83,  244,   84,
+ /*  1060 */    84,   43,   84,   43,  156,  157,  158,   84,   43,  161,
+ /*  1070 */   284,  365,  364,  265,  320,  167,  361,  284,  292,   43,
+ /*  1080 */   265,   43,   43,  297,    0,  299,   43,  263,  180,  146,
+ /*  1090 */    84,  183,  296,  185,  186,  187,  188,  189,  190,  327,
+ /*  1100 */   352,  345,   84,  368,   84,  368,  368,  355,  288,   84,
+ /*  1110 */   324,   83,  169,  225,  328,  329,  330,  331,  332,  333,
+ /*  1120 */    84,  335,   84,   84,  338,   12,   13,   84,  342,  343,
+ /*  1130 */   344,  223,   48,  322,   20,   22,  264,   47,  321,  353,
+ /*  1140 */   256,   35,  162,  270,  315,  264,   33,  264,   35,   42,
+ /*  1150 */   304,   33,  302,  166,  211,  212,  213,  214,  215,  216,
+ /*  1160 */   217,  218,  219,  220,  166,   47,  256,  146,  284,   56,
+ /*  1170 */    52,   53,   54,   55,   56,   20,  292,    4,  302,   66,
+ /*  1180 */   264,  297,  264,  299,  258,  258,   20,  319,  299,  268,
+ /*  1190 */   268,   20,   19,  314,  284,   20,   20,  312,  268,  312,
+ /*  1200 */    82,  268,  292,   85,  305,  268,   33,  297,  324,  299,
+ /*  1210 */   268,  264,  328,  329,  330,  331,  332,  333,  105,  335,
+ /*  1220 */    47,  268,  338,  258,   51,  284,  342,  343,  344,   56,
+ /*  1230 */   284,  297,  284,  256,  324,  284,  284,  353,  328,  329,
+ /*  1240 */   330,  331,  332,  333,  284,  335,  284,  284,  338,  264,
+ /*  1250 */   284,  258,  342,  343,  344,   82,  284,  284,   85,  319,
+ /*  1260 */   266,  284,  318,  353,  172,  147,  148,  299,  150,  292,
+ /*  1270 */   266,  264,  154,  264,  297,  230,  299,  164,  266,  166,
+ /*  1280 */   148,  297,  312,  297,  292,  297,  256,  308,  297,  308,
+ /*  1290 */   313,  173,  297,  266,  280,  306,  256,  266,   20,  231,
+ /*  1300 */   292,  324,  305,  237,  191,  328,  329,  330,  331,  332,
+ /*  1310 */   333,  308,  335,  297,  284,  202,  203,  204,  205,  206,
+ /*  1320 */   207,  208,  292,  327,  284,  308,  297,  297,  239,  299,
+ /*  1330 */   297,  354,  292,  155,  297,  238,  226,  297,  297,  299,
+ /*  1340 */   292,  222,  360,  313,  367,  322,   20,  243,  371,  241,
+ /*  1350 */   360,  256,   83,  288,  324,  246,  297,  358,  328,  329,
+ /*  1360 */   330,  331,  332,  333,  324,  335,  264,  256,  328,  329,
+ /*  1370 */   330,  331,  332,  333,  363,  335,  357,  362,  338,  284,
+ /*  1380 */   326,  359,  342,  343,  354,  375,  274,  292,  341,  266,
+ /*  1390 */    36,  258,  297,  369,  299,  284,  259,  367,  316,  311,
+ /*  1400 */   278,  371,  360,  292,  370,  370,  278,  278,  297,  267,
+ /*  1410 */   299,  254,    0,  369,  174,    0,  370,  256,  369,  324,
+ /*  1420 */     0,    0,   42,  328,  329,  330,  331,  332,  333,  334,
+ /*  1430 */   335,  336,  337,  256,   74,  324,    0,  184,   35,  328,
+ /*  1440 */   329,  330,  331,  332,  333,  284,  335,  184,   35,   35,
+ /*  1450 */     0,   35,   35,  292,   35,  184,    0,  184,  297,    0,
+ /*  1460 */   299,  284,   35,    0,   22,    0,  289,   35,    0,  292,
+ /*  1470 */    83,  169,  168,  166,  297,  256,  299,  164,    0,    0,
+ /*  1480 */   160,  159,    0,  372,  373,  324,    0,   46,    0,  328,
+ /*  1490 */   329,  330,  331,  332,  333,  256,  335,    0,    0,  338,
+ /*  1500 */   143,  324,    0,  284,  343,  328,  329,  330,  331,  332,
+ /*  1510 */   333,  292,  335,    0,    0,    0,  297,    0,  299,  138,
+ /*  1520 */    35,    0,  138,  284,    0,    0,    0,    0,  289,    0,
+ /*  1530 */     0,  292,   42,    0,    0,    0,  297,    0,  299,    0,
+ /*  1540 */     0,    0,    0,  324,    0,    0,    0,  328,  329,  330,
+ /*  1550 */   331,  332,  333,  256,  335,    0,    0,    0,   22,    0,
+ /*  1560 */     0,    0,    0,  324,    0,  256,   56,  328,  329,  330,
+ /*  1570 */   331,  332,  333,    0,  335,  256,    0,   14,    0,   14,
+ /*  1580 */    42,  284,   39,    0,    0,  366,    0,    0,   40,  292,
+ /*  1590 */    43,   39,  155,  284,  297,   46,  299,   46,  289,    0,
+ /*  1600 */     0,  292,    0,  284,    0,   39,  297,   35,  299,   39,
+ /*  1610 */     0,  292,   35,   39,   47,   61,  297,    0,  299,   39,
+ /*  1620 */    35,  324,   47,    0,    0,  328,  329,  330,  331,  332,
+ /*  1630 */   333,   35,  335,  324,    0,  256,   47,  328,  329,  330,
+ /*  1640 */   331,  332,  333,  324,  335,   47,   39,  328,  329,  330,
+ /*  1650 */   331,  332,  333,    0,  335,    0,  337,   35,  256,   90,
+ /*  1660 */    92,   22,    0,  284,   35,   35,   35,   35,  289,   43,
+ /*  1670 */   373,  292,   35,   35,    0,   35,  297,    0,  299,   43,
+ /*  1680 */    22,   22,   49,    0,   35,   22,  284,    0,    0,   35,
+ /*  1690 */     0,  289,   35,   22,  292,   20,    0,    0,  170,  297,
+ /*  1700 */   256,  299,   35,  324,   22,    0,  148,  328,  329,  330,
+ /*  1710 */   331,  332,  333,    0,  335,    0,    0,  256,   83,    0,
+ /*  1720 */     0,   93,  151,    0,   39,   84,  324,   83,  284,  179,
+ /*  1730 */   328,  329,  330,  331,  332,  333,  292,  335,   46,  151,
+ /*  1740 */    84,  297,  151,  299,   83,  284,  153,   43,   83,  227,
+ /*  1750 */   149,   83,  147,  292,   84,   83,   46,   84,  297,   83,
+ /*  1760 */   299,   22,   84,   83,   43,   84,   35,  256,  324,   83,
+ /*  1770 */    43,   46,  328,  329,  330,  331,  332,  333,   83,  335,
+ /*  1780 */    43,   83,   46,   84,   84,  324,   43,   46,  256,  328,
+ /*  1790 */   329,  330,  331,  332,  333,  284,  335,   46,   84,   43,
+ /*  1800 */    35,   84,  221,  292,   35,   35,  227,   35,  297,  256,
+ /*  1810 */   299,   35,    2,   83,   43,   83,  284,  227,  191,   84,
+ /*  1820 */    46,   46,   84,   83,  292,   22,   84,   94,   83,  297,
+ /*  1830 */    83,  299,   83,   35,   84,  324,  193,  284,   83,  328,
+ /*  1840 */   329,  330,  331,  332,  333,  292,  335,   35,   84,   35,
+ /*  1850 */   297,  256,  299,   35,   35,   35,  324,   84,   22,  107,
+ /*  1860 */   328,  329,  330,  331,  332,  333,   83,  335,  256,   83,
+ /*  1870 */   107,   84,   83,  107,   84,   83,   95,  324,   83,  284,
+ /*  1880 */    83,  328,  329,  330,  331,  332,  333,  292,  335,  107,
+ /*  1890 */    35,   83,  297,   43,  299,   22,  284,   66,   61,   60,
+ /*  1900 */    35,   43,   81,   35,  292,   35,   35,   35,   22,  297,
+ /*  1910 */    35,  299,   35,   35,   66,   35,   35,   35,   35,  324,
+ /*  1920 */   256,   47,   35,  328,  329,  330,  331,  332,  333,   35,
+ /*  1930 */   335,   35,    0,   35,   39,    0,  324,   35,   47,   39,
+ /*  1940 */   328,  329,  330,  331,  332,  333,    0,  335,  284,   35,
+ /*  1950 */    47,   39,    0,   35,   47,   39,  292,    0,   35,   35,
+ /*  1960 */     0,  297,   22,  299,   21,  376,   22,   22,   21,   20,
+ /*  1970 */   376,  376,  376,  376,  256,  376,  376,  376,  376,  376,
+ /*  1980 */   376,  376,  376,  376,  376,  376,  376,  376,  324,  376,
+ /*  1990 */   256,  376,  328,  329,  330,  331,  332,  333,  376,  335,
+ /*  2000 */   256,  376,  284,  376,  376,  376,  376,  376,  376,  376,
+ /*  2010 */   292,  376,  376,  376,  376,  297,  376,  299,  284,  376,
+ /*  2020 */   376,  376,  376,  376,  376,  376,  292,  376,  284,  376,
+ /*  2030 */   376,  297,  376,  299,  376,  376,  292,  376,  376,  376,
+ /*  2040 */   376,  297,  324,  299,  376,  376,  328,  329,  330,  331,
+ /*  2050 */   332,  333,  256,  335,  376,  376,  376,  376,  324,  376,
+ /*  2060 */   376,  376,  328,  329,  330,  331,  332,  333,  324,  335,
+ /*  2070 */   376,  376,  328,  329,  330,  331,  332,  333,  376,  335,
+ /*  2080 */   284,  376,  376,  376,  376,  376,  376,  376,  292,  376,
+ /*  2090 */   376,  376,  376,  297,  256,  299,  376,  376,  376,  376,
+ /*  2100 */   376,  376,  376,  376,  376,  376,  376,  376,  256,  376,
+ /*  2110 */   376,  376,  376,  376,  376,  376,  376,  376,  256,  376,
+ /*  2120 */   324,  376,  284,  376,  328,  329,  330,  331,  332,  333,
+ /*  2130 */   292,  335,  376,  376,  376,  297,  284,  299,  376,  376,
+ /*  2140 */   376,  376,  376,  376,  292,  376,  284,  376,  376,  297,
+ /*  2150 */   376,  299,  376,  376,  292,  376,  376,  376,  376,  297,
+ /*  2160 */   376,  299,  324,  376,  376,  376,  328,  329,  330,  331,
+ /*  2170 */   332,  333,  376,  335,  376,  376,  324,  256,  376,  376,
+ /*  2180 */   328,  329,  330,  331,  332,  333,  324,  335,  376,  376,
+ /*  2190 */   328,  329,  330,  331,  332,  333,  376,  335,  256,  376,
+ /*  2200 */   376,  376,  376,  376,  376,  284,  376,  376,  376,  376,
+ /*  2210 */   376,  376,  376,  292,  376,  376,  376,  376,  297,  376,
+ /*  2220 */   299,  376,  376,  376,  376,  376,  284,  376,  376,  376,
+ /*  2230 */   376,  376,  376,  376,  292,  376,  376,  376,  376,  297,
+ /*  2240 */   376,  299,  376,  376,  376,  324,  376,  376,  376,  328,
+ /*  2250 */   329,  330,  331,  332,  333,  376,  335,  256,  376,  376,
+ /*  2260 */   376,  376,  376,  376,  376,  376,  324,  256,  376,  376,
+ /*  2270 */   328,  329,  330,  331,  332,  333,  376,  335,  376,  376,
+ /*  2280 */   376,  376,  376,  256,  376,  284,  376,  376,  376,  376,
+ /*  2290 */   376,  376,  376,  292,  376,  284,  376,  376,  297,  376,
+ /*  2300 */   299,  376,  376,  292,  376,  376,  376,  376,  297,  376,
+ /*  2310 */   299,  284,  376,  376,  376,  376,  376,  376,  376,  292,
+ /*  2320 */   376,  376,  376,  376,  297,  324,  299,  376,  376,  328,
+ /*  2330 */   329,  330,  331,  332,  333,  324,  335,  376,  376,  328,
+ /*  2340 */   329,  330,  331,  332,  333,  376,  335,  376,  376,  376,
+ /*  2350 */   376,  324,  376,  376,  376,  328,  329,  330,  331,  332,
+ /*  2360 */   333,  376,  335,
 };
-#define YY_SHIFT_COUNT    (655)
+#define YY_SHIFT_COUNT    (660)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1939)
+#define YY_SHIFT_MAX      (1960)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   895,    0,    0,   57,   57,  255,  255,  255,  312,  312,
- /*    10 */   255,  255,  510,  567,  765,  567,  567,  567,  567,  567,
- /*    20 */   567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
- /*    30 */   567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
- /*    40 */   567,  567,  567,   64,   64,   86,   86,   86, 1166, 1166,
- /*    50 */  1166,  147,   52,  151,   11,   11,  440,  440,   58,   30,
- /*    60 */   151,  151,   11,   11,   11,   11,   11,   11,   11,   11,
- /*    70 */    22,   11,   11,   11,   26,  271,   11,   11,  271,  376,
- /*    80 */    11,  271,  271,  271,   11,  423,  761,  224,  479,  479,
- /*    90 */    13,  266, 1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085,
- /*   100 */  1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085,
- /*   110 */  1085,  206,   30,   81,   81,  115,  586,  605,   41,   41,
- /*   120 */    41,  586,  511,   26,  643,  643,  271,  271,  658,  658,
- /*   130 */   692,  671,  253,  253,  253,  253,  253,  253,  253,  509,
- /*   140 */   720,  309,  291,   38,  524,  305,  418,  617,  657,  267,
- /*   150 */   621,  372,   98,  572,  703,  572,  813,  238,  238,  238,
- /*   160 */    60,  562,  889, 1099, 1076, 1095,  973, 1099, 1099, 1115,
- /*   170 */  1022, 1022, 1099, 1099, 1161, 1161, 1178,   22,   26,   22,
- /*   180 */  1186, 1187,   22, 1186,   22, 1204,   22,   22, 1099,   22,
- /*   190 */  1161,  271,  271,  271,  271,  271,  271,  271,  271,  271,
- /*   200 */   271,  271, 1099, 1161,  658, 1178,  423, 1098,   26,  423,
- /*   210 */  1099, 1099, 1186,  423, 1062,  658,  658,  658,  658, 1062,
- /*   220 */   658, 1146,  511, 1204,  423,  692,  423,  511, 1299,  658,
- /*   230 */  1094, 1062,  658,  658, 1094, 1062,  658,  658,  271, 1104,
- /*   240 */  1176, 1094, 1097, 1106, 1119,  889, 1125,  511, 1328, 1108,
- /*   250 */  1142, 1120, 1108, 1142, 1108, 1142, 1301, 1307,  658,  671,
- /*   260 */  1099,  423, 1363, 1161, 2401, 2401, 2401, 2401, 2401, 2401,
- /*   270 */  2401,  335,  986,  188,  521,  414,  457,  713,  626,  826,
- /*   280 */   907, 1520,  688,  865,  865,  865,  865,  865,  865,  865,
- /*   290 */   865, 1032,  272,   14,   14,  469,  367,  513,  722,  139,
- /*   300 */    34,   95,  584,  669,  669,  669,  669,  560,  959,  821,
- /*   310 */   822,  840,  847,  836,  917,  991,  797,  789,  965, 1005,
- /*   320 */  1024, 1026, 1027, 1034,  837,  962, 1053,  998,  892,  296,
- /*   330 */   349, 1060,  886, 1069,  983, 1030, 1089, 1109, 1137, 1151,
- /*   340 */  1152,  152,  961,  231, 1430, 1436, 1395, 1438, 1366, 1441,
- /*   350 */  1408, 1258, 1409, 1411, 1412, 1264, 1450, 1416, 1417, 1269,
- /*   360 */  1455, 1272, 1458, 1424, 1460, 1443, 1463, 1432, 1468, 1387,
- /*   370 */  1302, 1304, 1309, 1313, 1478, 1479, 1320, 1323, 1483, 1484,
- /*   380 */  1439, 1487, 1490, 1491, 1349, 1499, 1502, 1504, 1511, 1514,
- /*   390 */  1377, 1481, 1525, 1388, 1527, 1530, 1537, 1538, 1545, 1547,
- /*   400 */  1548, 1549, 1550, 1552, 1553, 1554, 1557, 1558, 1498, 1541,
- /*   410 */  1542, 1543, 1560, 1561, 1562, 1546, 1563, 1565, 1567, 1569,
- /*   420 */  1570, 1516, 1574, 1581, 1544, 1551, 1564, 1573, 1559, 1575,
- /*   430 */  1566, 1583, 1568, 1555, 1584, 1588, 1592, 1571, 1448, 1593,
- /*   440 */  1606, 1611, 1556, 1615, 1619, 1587, 1576, 1585, 1625, 1594,
- /*   450 */  1580, 1591, 1631, 1597, 1586, 1595, 1635, 1601, 1596, 1599,
- /*   460 */  1639, 1640, 1642, 1644, 1577, 1578, 1616, 1633, 1656, 1632,
- /*   470 */  1636, 1637, 1641, 1623, 1634, 1646, 1647, 1648, 1674, 1653,
- /*   480 */  1679, 1662, 1638, 1685, 1664, 1654, 1688, 1655, 1692, 1658,
- /*   490 */  1694, 1673, 1676, 1697, 1572, 1665, 1698, 1531, 1680, 1582,
- /*   500 */  1579, 1703, 1707, 1590, 1598, 1708, 1717, 1719, 1643, 1645,
- /*   510 */  1536, 1720, 1649, 1600, 1651, 1721, 1683, 1603, 1660, 1652,
- /*   520 */  1678, 1682, 1518, 1669, 1671, 1670, 1672, 1681, 1677, 1706,
- /*   530 */  1704, 1684, 1686, 1687, 1689, 1690, 1714, 1702, 1716, 1693,
- /*   540 */  1724, 1589, 1691, 1695, 1718, 1605, 1734, 1732, 1735, 1699,
- /*   550 */  1739, 1604, 1700, 1728, 1750, 1752, 1753, 1754, 1764, 1700,
- /*   560 */  1798, 1620, 1758, 1729, 1727, 1730, 1733, 1731, 1736, 1772,
- /*   570 */  1743, 1744, 1773, 1800, 1650, 1745, 1737, 1749, 1794, 1799,
- /*   580 */  1755, 1751, 1801, 1757, 1759, 1806, 1761, 1762, 1810, 1766,
- /*   590 */  1763, 1815, 1768, 1756, 1760, 1769, 1771, 1838, 1770, 1778,
- /*   600 */  1779, 1831, 1791, 1836, 1836, 1858, 1820, 1822, 1848, 1818,
- /*   610 */  1804, 1844, 1853, 1854, 1855, 1856, 1857, 1873, 1861, 1862,
- /*   620 */  1827, 1623, 1863, 1634, 1865, 1867, 1868, 1869, 1872, 1874,
- /*   630 */  1906, 1875, 1864, 1876, 1908, 1877, 1870, 1882, 1914, 1881,
- /*   640 */  1878, 1883, 1923, 1889, 1880, 1890, 1928, 1901, 1903, 1939,
- /*   650 */  1918, 1920, 1922, 1924, 1927, 1937,
+ /*     0 */   908,    0,    0,   67,   67,  266,  266,  266,  323,  323,
+ /*    10 */   266,  266,  522,  579,  778,  579,  579,  579,  579,  579,
+ /*    20 */   579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
+ /*    30 */   579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
+ /*    40 */   579,  579,  579,  364,  364,    8,    8,    8, 1113, 1113,
+ /*    50 */  1113,  128,  172,   31,   31,  154,  154,   93,   93,   64,
+ /*    60 */    70,   31,   31,  154,  154,  154,  154,  154,  154,  154,
+ /*    70 */   154,  154,   16,  154,  154,  154,  240,  322,  154,  154,
+ /*    80 */   322,  340,  154,  322,  322,  322,  154,  368,  774,  490,
+ /*    90 */   943,  943,  372,   55,  317,  317,  317,  317,  317,  317,
+ /*   100 */   317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
+ /*   110 */   317,  317,  317,  463,   70,   12,   12,  300,  380,  328,
+ /*   120 */   434,  434,  434,  380,  557,  240,    5,    5,  322,  322,
+ /*   130 */   586,  586,  591,  625,  206,  206,  206,  206,  206,  206,
+ /*   140 */   206,  777,   23,  593,  425,   48,  341,  251,  268,  439,
+ /*   150 */   569,   51,  705,  775,  646,  672,  789,  672,  895,  769,
+ /*   160 */   769,  769,  693,  773, 1028,  888, 1114, 1090, 1106,  980,
+ /*   170 */  1114, 1114, 1107, 1021, 1021, 1114, 1114, 1155, 1155, 1166,
+ /*   180 */    16,  240,   16, 1171, 1175,   16, 1171,   16, 1176,   16,
+ /*   190 */    16, 1114,   16, 1155,  322,  322,  322,  322,  322,  322,
+ /*   200 */   322,  322,  322,  322,  322, 1114, 1155,  586, 1166,  368,
+ /*   210 */  1092,  240,  368, 1114, 1114, 1171,  368, 1045,  586,  586,
+ /*   220 */   586,  586, 1045,  586, 1132,  557, 1176,  368,  591,  368,
+ /*   230 */   557, 1278,  586, 1068, 1045,  586,  586, 1068, 1045,  586,
+ /*   240 */   586,  322, 1066, 1178, 1068, 1089, 1097, 1110,  888, 1119,
+ /*   250 */   557, 1326, 1104, 1108, 1109, 1104, 1108, 1104, 1108, 1269,
+ /*   260 */  1028,  586,  625, 1114,  368, 1354, 1155, 2363, 2363, 2363,
+ /*   270 */  2363, 2363, 2363, 2363,  173, 1118,  188, 1173,  143,  594,
+ /*   280 */   663,  744,  753,  726,  920,  480,    2,    2,    2,    2,
+ /*   290 */     2,    2,    2,    2,  700,   53,   26,   26,   46,  139,
+ /*   300 */   568,  106,  415,  118,  476,  657,  524,  524,  524,  524,
+ /*   310 */   494,  246,  903,  909,  911,  923,  939,  967, 1002,  959,
+ /*   320 */   865,  807,  969,  971,  975,  976,  978,  987,  998,  983,
+ /*   330 */  1026,  928,  179,  814, 1006,  553, 1018,  974, 1020, 1025,
+ /*   340 */  1036, 1038, 1039, 1043,  507,  420, 1084, 1412, 1240, 1415,
+ /*   350 */  1420, 1380, 1421, 1360, 1436, 1403, 1253, 1413, 1414, 1416,
+ /*   360 */  1263, 1450, 1417, 1419, 1271, 1456, 1273, 1459, 1427, 1463,
+ /*   370 */  1442, 1465, 1432, 1468, 1387, 1302, 1304, 1307, 1313, 1478,
+ /*   380 */  1479, 1320, 1322, 1482, 1486, 1441, 1488, 1497, 1498, 1357,
+ /*   390 */  1502, 1513, 1514, 1515, 1517, 1381, 1485, 1521, 1384, 1524,
+ /*   400 */  1525, 1526, 1527, 1529, 1530, 1537, 1539, 1540, 1541, 1542,
+ /*   410 */  1544, 1545, 1546, 1490, 1533, 1534, 1535, 1555, 1556, 1557,
+ /*   420 */  1536, 1559, 1560, 1561, 1562, 1564, 1510, 1573, 1576, 1538,
+ /*   430 */  1543, 1547, 1563, 1549, 1565, 1551, 1578, 1548, 1552, 1583,
+ /*   440 */  1584, 1586, 1566, 1437, 1587, 1599, 1600, 1554, 1602, 1604,
+ /*   450 */  1572, 1567, 1570, 1610, 1577, 1575, 1574, 1617, 1585, 1589,
+ /*   460 */  1580, 1623, 1596, 1598, 1607, 1624, 1634, 1653, 1655, 1568,
+ /*   470 */  1569, 1622, 1639, 1662, 1629, 1630, 1631, 1632, 1626, 1636,
+ /*   480 */  1637, 1638, 1640, 1674, 1658, 1677, 1659, 1633, 1683, 1663,
+ /*   490 */  1649, 1687, 1654, 1688, 1657, 1690, 1671, 1675, 1696, 1571,
+ /*   500 */  1667, 1697, 1528, 1682, 1588, 1558, 1705, 1713, 1591, 1593,
+ /*   510 */  1715, 1716, 1723, 1635, 1641, 1550, 1719, 1644, 1601, 1661,
+ /*   520 */  1720, 1685, 1605, 1665, 1628, 1692, 1704, 1522, 1668, 1656,
+ /*   530 */  1672, 1670, 1673, 1676, 1739, 1721, 1678, 1680, 1686, 1695,
+ /*   540 */  1681, 1727, 1710, 1725, 1698, 1737, 1579, 1699, 1700, 1736,
+ /*   550 */  1581, 1743, 1741, 1751, 1714, 1756, 1590, 1717, 1731, 1765,
+ /*   560 */  1769, 1770, 1772, 1776, 1717, 1810, 1627, 1771, 1730, 1735,
+ /*   570 */  1732, 1738, 1740, 1742, 1774, 1745, 1747, 1775, 1803, 1643,
+ /*   580 */  1749, 1733, 1750, 1798, 1812, 1755, 1764, 1814, 1783, 1773,
+ /*   590 */  1818, 1786, 1787, 1819, 1789, 1790, 1820, 1792, 1752, 1763,
+ /*   600 */  1766, 1782, 1836, 1781, 1795, 1797, 1855, 1808, 1850, 1850,
+ /*   610 */  1873, 1837, 1839, 1865, 1831, 1821, 1858, 1868, 1870, 1871,
+ /*   620 */  1872, 1875, 1886, 1877, 1878, 1848, 1626, 1880, 1636, 1881,
+ /*   630 */  1882, 1883, 1887, 1894, 1896, 1932, 1898, 1874, 1895, 1935,
+ /*   640 */  1902, 1891, 1900, 1946, 1914, 1903, 1912, 1952, 1918, 1907,
+ /*   650 */  1916, 1957, 1923, 1924, 1960, 1940, 1943, 1944, 1945, 1947,
+ /*   660 */  1949,
 };
-#define YY_REDUCE_COUNT (270)
-#define YY_REDUCE_MIN   (-339)
-#define YY_REDUCE_MAX   (2065)
+#define YY_REDUCE_COUNT (273)
+#define YY_REDUCE_MIN   (-295)
+#define YY_REDUCE_MAX   (2027)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -245, -199,  693,  651,  762,  325,  832,  885,  949, 1029,
- /*    10 */   533,  969, 1082, -146, 1096, 1165, 1177, 1189, 1247, 1267,
- /*    20 */  1317, 1329, 1381, 1407, 1462, 1474, 1524, 1540, 1602, 1621,
- /*    30 */  1663, 1705, 1715, 1767, 1793, 1809, 1859, 1871, 1921, 1963,
- /*    40 */  2005, 2015, 2065, -260,  265, -190,  204,  908, -276, -272,
- /*    50 */    -4, -289, -255,  -69, -112,  326, -257, -244, -200, -171,
- /*    60 */  -125,  -41, -189,  283,  387,  526,  545,  552,  558,  650,
- /*    70 */  -214,  712,  745,  780,  289,  140,  810,  823,  190, -275,
- /*    80 */   879,  257,  320,  531,  891, -264, -228, -339, -339, -339,
- /*    90 */    21, -262, -176, -152,   25,  121,  230,  241,  329,  405,
- /*   100 */   443,  487,  498,  499,  557,  563,  570,  613,  648,  691,
- /*   110 */   701,   31,  -74,  130,  240,   28,   73,  472,   75,  149,
- /*   120 */   260,  111,  378,  424,   37,  364,  530, -119,  276,  438,
- /*   130 */   459,  508,  544,  564,  574,  641,  653,  659,  666,  535,
- /*   140 */   590,  655,  580,  636,  740,  690,  673,  730,  730,  785,
- /*   150 */   767,  749,  736,  705,  705,  705,  734,  697,  731,  733,
- /*   160 */   754,  730,  799,  858,  804,  868,  824,  878,  881,  854,
- /*   170 */   884,  887,  923,  927,  934,  938,  883,  929,  904,  936,
- /*   180 */   896,  897,  942,  900,  951,  921,  963,  966,  975,  974,
- /*   190 */   972,  953,  960,  968,  970,  976,  979,  980,  981,  985,
- /*   200 */   988,  990,  994,  987,  946,  928,  984,  971,  989, 1001,
- /*   210 */  1019, 1023,  978, 1020,  997,  995,  999, 1009, 1011, 1002,
- /*   220 */  1012, 1008, 1003, 1010, 1051, 1038, 1056, 1031, 1000, 1028,
- /*   230 */   977, 1021, 1036, 1037, 1015, 1033, 1039, 1042,  730,  982,
- /*   240 */   992, 1016,  996,  993, 1006, 1025,  705, 1057, 1052, 1007,
- /*   250 */  1017, 1014, 1035, 1018, 1065, 1040, 1044, 1103, 1100, 1118,
- /*   260 */  1130, 1132, 1143, 1145, 1088, 1090, 1129, 1144, 1154, 1141,
- /*   270 */  1169,
+ /*     0 */  -192, -189,   81,  287,  708,  786,  884,  910,  977, 1030,
+ /*    10 */   543, 1040, 1095, 1111, 1161, 1177, 1239, 1219, 1297, 1309,
+ /*    20 */  1319, 1379, 1402, 1444, 1461, 1511, 1532, 1553, 1595, 1612,
+ /*    30 */  1664, 1718, 1734, 1744, 1796, 1838, 1852, 1862, 1921, 1942,
+ /*    40 */  2001, 2011, 2027, -255,   21,  215, -263,  221, -261, -278,
+ /*    50 */   121, -289,  -23,  -21,   10,   65,  357, -260, -256, -295,
+ /*    60 */  -268, -239, -191,   63,  218,  220,  273,  281,  369,  382,
+ /*    70 */   390,  419, -247,  544,  545,  574, -201,  283,  577,  679,
+ /*    80 */  -107,   90,  731,  397,  396,  567,  733,   75, -194, -114,
+ /*    90 */  -114, -114, -144,  -88, -152,  111,  134,  194,  392,  436,
+ /*   100 */   549,  550,  551,  556,  566,  583,  623,  626,  628,  633,
+ /*   110 */   665,  666,  697,  205,   -2,  362,  451,  -34,   54,  224,
+ /*   120 */   166,  278,  538,  466,  355,  555, -175,  329,  470,  640,
+ /*   130 */   454,  561,  610,  421,  517,  560,  656,  662,  675,  745,
+ /*   140 */   746,  717,  788,  781,  682,  706,  808,  754,  715,  793,
+ /*   150 */   793,  815,  824,  796,  772,  748,  748,  748,  756,  735,
+ /*   160 */   737,  738,  752,  793,  820,  811,  872,  817,  873,  829,
+ /*   170 */   881,  883,  846,  850,  876,  916,  918,  926,  927,  868,
+ /*   180 */   921,  889,  922,  885,  879,  930,  887,  933,  899,  937,
+ /*   190 */   942,  947,  953,  965,  941,  946,  948,  951,  952,  960,
+ /*   200 */   962,  963,  966,  972,  973,  985,  993,  934,  940,  994,
+ /*   210 */   944,  968, 1004, 1007, 1009,  970, 1012,  979,  984,  986,
+ /*   220 */   988,  991,  981,  995,  989,  992,  997, 1027, 1014, 1031,
+ /*   230 */  1008,  996, 1016,  982, 1003, 1029, 1033,  990, 1017, 1037,
+ /*   240 */  1041,  793, 1011, 1015, 1042, 1022,  999, 1019, 1023,  748,
+ /*   250 */  1048, 1054, 1034, 1024, 1010, 1035, 1044, 1046, 1049, 1047,
+ /*   260 */  1065, 1059, 1112, 1102, 1123, 1137, 1133, 1082, 1088, 1122,
+ /*   270 */  1128, 1129, 1142, 1157,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    10 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    20 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    30 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    40 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    50 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    60 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    70 */  1514, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*    80 */  1441, 1441, 1441, 1441, 1441, 1512, 1665, 1441, 1841, 1441,
- /*    90 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   100 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   110 */  1441, 1441, 1441, 1441, 1441, 1514, 1441, 1512, 1853, 1853,
- /*   120 */  1853, 1441, 1441, 1441, 1709, 1709, 1441, 1441, 1441, 1441,
- /*   130 */  1608, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1701,
- /*   140 */  1441, 1441, 1922, 1441, 1441, 1707, 1876, 1441, 1441, 1441,
- /*   150 */  1441, 1561, 1868, 1845, 1859, 1846, 1843, 1907, 1907, 1907,
- /*   160 */  1862, 1441, 1872, 1441, 1441, 1441, 1693, 1441, 1441, 1670,
- /*   170 */  1667, 1667, 1441, 1441, 1441, 1441, 1441, 1514, 1441, 1514,
- /*   180 */  1441, 1441, 1514, 1441, 1514, 1441, 1514, 1514, 1441, 1514,
- /*   190 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   200 */  1441, 1441, 1441, 1441, 1441, 1441, 1512, 1703, 1441, 1512,
- /*   210 */  1441, 1441, 1441, 1512, 1881, 1441, 1441, 1441, 1441, 1881,
- /*   220 */  1441, 1441, 1441, 1441, 1512, 1441, 1512, 1441, 1441, 1441,
- /*   230 */  1883, 1881, 1441, 1441, 1883, 1881, 1441, 1441, 1441, 1895,
- /*   240 */  1891, 1883, 1899, 1897, 1874, 1872, 1859, 1441, 1441, 1913,
- /*   250 */  1909, 1925, 1913, 1909, 1913, 1909, 1441, 1577, 1441, 1441,
- /*   260 */  1441, 1512, 1473, 1441, 1695, 1709, 1611, 1611, 1611, 1515,
- /*   270 */  1446, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   280 */  1441, 1441, 1441, 1779, 1894, 1893, 1817, 1816, 1815, 1813,
- /*   290 */  1778, 1441, 1573, 1777, 1776, 1441, 1441, 1441, 1441, 1441,
- /*   300 */  1441, 1441, 1441, 1770, 1771, 1769, 1768, 1441, 1441, 1441,
- /*   310 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   320 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1842, 1441, 1910,
- /*   330 */  1914, 1441, 1441, 1441, 1753, 1441, 1441, 1441, 1441, 1441,
- /*   340 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   350 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   360 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   370 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   380 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   390 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   400 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   410 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   420 */  1441, 1441, 1441, 1441, 1441, 1441, 1478, 1441, 1441, 1441,
- /*   430 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   440 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   450 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   460 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   470 */  1441, 1441, 1441, 1542, 1541, 1441, 1441, 1441, 1441, 1441,
- /*   480 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   490 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   500 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   510 */  1441, 1713, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   520 */  1441, 1875, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   530 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1753, 1441,
- /*   540 */  1892, 1441, 1852, 1848, 1441, 1441, 1844, 1752, 1441, 1441,
- /*   550 */  1908, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   560 */  1837, 1441, 1810, 1795, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   570 */  1441, 1441, 1441, 1441, 1764, 1441, 1441, 1441, 1441, 1441,
- /*   580 */  1605, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   590 */  1441, 1441, 1441, 1590, 1588, 1587, 1586, 1441, 1583, 1441,
- /*   600 */  1441, 1441, 1441, 1614, 1613, 1441, 1441, 1441, 1441, 1441,
- /*   610 */  1441, 1534, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   620 */  1441, 1525, 1441, 1524, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   630 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   640 */  1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441,
- /*   650 */  1441, 1441, 1441, 1441, 1441, 1441,
+ /*     0 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    10 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    20 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    30 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    40 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    50 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    60 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    70 */  1447, 1447, 1520, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*    80 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1518, 1671, 1447,
+ /*    90 */  1848, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   100 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   110 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1520, 1447, 1518,
+ /*   120 */  1860, 1860, 1860, 1447, 1447, 1447, 1715, 1715, 1447, 1447,
+ /*   130 */  1447, 1447, 1614, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   140 */  1447, 1707, 1447, 1447, 1929, 1447, 1447, 1713, 1883, 1447,
+ /*   150 */  1447, 1447, 1447, 1567, 1875, 1852, 1866, 1853, 1850, 1914,
+ /*   160 */  1914, 1914, 1869, 1447, 1583, 1879, 1447, 1447, 1447, 1699,
+ /*   170 */  1447, 1447, 1676, 1673, 1673, 1447, 1447, 1447, 1447, 1447,
+ /*   180 */  1520, 1447, 1520, 1447, 1447, 1520, 1447, 1520, 1447, 1520,
+ /*   190 */  1520, 1447, 1520, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   200 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1518,
+ /*   210 */  1709, 1447, 1518, 1447, 1447, 1447, 1518, 1888, 1447, 1447,
+ /*   220 */  1447, 1447, 1888, 1447, 1447, 1447, 1447, 1518, 1447, 1518,
+ /*   230 */  1447, 1447, 1447, 1890, 1888, 1447, 1447, 1890, 1888, 1447,
+ /*   240 */  1447, 1447, 1902, 1898, 1890, 1906, 1904, 1881, 1879, 1866,
+ /*   250 */  1447, 1447, 1920, 1916, 1932, 1920, 1916, 1920, 1916, 1447,
+ /*   260 */  1583, 1447, 1447, 1447, 1518, 1479, 1447, 1701, 1715, 1617,
+ /*   270 */  1617, 1617, 1521, 1452, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   280 */  1447, 1447, 1447, 1447, 1447, 1447, 1786, 1901, 1900, 1824,
+ /*   290 */  1823, 1822, 1820, 1785, 1447, 1579, 1784, 1783, 1447, 1447,
+ /*   300 */  1447, 1447, 1447, 1447, 1447, 1447, 1777, 1778, 1776, 1775,
+ /*   310 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   320 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   330 */  1849, 1447, 1917, 1921, 1447, 1447, 1447, 1760, 1447, 1447,
+ /*   340 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   350 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   360 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   370 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   380 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   390 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   400 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   410 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   420 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   430 */  1447, 1484, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   440 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   450 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   460 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   470 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1548, 1547,
+ /*   480 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   490 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   500 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   510 */  1447, 1447, 1447, 1447, 1447, 1447, 1719, 1447, 1447, 1447,
+ /*   520 */  1447, 1447, 1447, 1447, 1447, 1447, 1882, 1447, 1447, 1447,
+ /*   530 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   540 */  1447, 1447, 1447, 1760, 1447, 1899, 1447, 1859, 1855, 1447,
+ /*   550 */  1447, 1851, 1759, 1447, 1447, 1915, 1447, 1447, 1447, 1447,
+ /*   560 */  1447, 1447, 1447, 1447, 1447, 1844, 1447, 1817, 1802, 1447,
+ /*   570 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1771,
+ /*   580 */  1447, 1447, 1447, 1447, 1447, 1611, 1447, 1447, 1447, 1447,
+ /*   590 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1596, 1594,
+ /*   600 */  1593, 1592, 1447, 1589, 1447, 1447, 1447, 1447, 1620, 1619,
+ /*   610 */  1447, 1447, 1447, 1447, 1447, 1447, 1540, 1447, 1447, 1447,
+ /*   620 */  1447, 1447, 1447, 1447, 1447, 1447, 1531, 1447, 1530, 1447,
+ /*   630 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   640 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   650 */  1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447, 1447,
+ /*   660 */  1447,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1083,6 +1077,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*      SPLIT => nothing */
     0,  /*     SYNCDB => nothing */
     0,  /*     DELETE => nothing */
+    0,  /*     INSERT => nothing */
     0,  /*       NULL => nothing */
     0,  /* NK_QUESTION => nothing */
     0,  /*   NK_ARROW => nothing */
@@ -1140,12 +1135,11 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*        ASC => nothing */
     0,  /*      NULLS => nothing */
     0,  /*         ID => nothing */
-  246,  /*  NK_BITNOT => ID */
-  246,  /*     INSERT => ID */
-  246,  /*     VALUES => ID */
-  246,  /*     IMPORT => ID */
-  246,  /*    NK_SEMI => ID */
-  246,  /*       FILE => ID */
+  247,  /*  NK_BITNOT => ID */
+  247,  /*     VALUES => ID */
+  247,  /*     IMPORT => ID */
+  247,  /*    NK_SEMI => ID */
+  247,  /*       FILE => ID */
 };
 #endif /* YYFALLBACK */
 
@@ -1423,65 +1417,65 @@ static const char *const yyTokenName[] = {
   /*  187 */ "SPLIT",
   /*  188 */ "SYNCDB",
   /*  189 */ "DELETE",
-  /*  190 */ "NULL",
-  /*  191 */ "NK_QUESTION",
-  /*  192 */ "NK_ARROW",
-  /*  193 */ "ROWTS",
-  /*  194 */ "TBNAME",
-  /*  195 */ "QSTARTTS",
-  /*  196 */ "QENDTS",
-  /*  197 */ "WSTARTTS",
-  /*  198 */ "WENDTS",
-  /*  199 */ "WDURATION",
-  /*  200 */ "CAST",
-  /*  201 */ "NOW",
-  /*  202 */ "TODAY",
-  /*  203 */ "TIMEZONE",
-  /*  204 */ "CLIENT_VERSION",
-  /*  205 */ "SERVER_VERSION",
-  /*  206 */ "SERVER_STATUS",
-  /*  207 */ "CURRENT_USER",
-  /*  208 */ "COUNT",
-  /*  209 */ "LAST_ROW",
-  /*  210 */ "BETWEEN",
-  /*  211 */ "IS",
-  /*  212 */ "NK_LT",
-  /*  213 */ "NK_GT",
-  /*  214 */ "NK_LE",
-  /*  215 */ "NK_GE",
-  /*  216 */ "NK_NE",
-  /*  217 */ "MATCH",
-  /*  218 */ "NMATCH",
-  /*  219 */ "CONTAINS",
-  /*  220 */ "JOIN",
-  /*  221 */ "INNER",
-  /*  222 */ "SELECT",
-  /*  223 */ "DISTINCT",
-  /*  224 */ "WHERE",
-  /*  225 */ "PARTITION",
-  /*  226 */ "BY",
-  /*  227 */ "SESSION",
-  /*  228 */ "STATE_WINDOW",
-  /*  229 */ "SLIDING",
-  /*  230 */ "FILL",
-  /*  231 */ "VALUE",
-  /*  232 */ "NONE",
-  /*  233 */ "PREV",
-  /*  234 */ "LINEAR",
-  /*  235 */ "NEXT",
-  /*  236 */ "HAVING",
-  /*  237 */ "RANGE",
-  /*  238 */ "EVERY",
-  /*  239 */ "ORDER",
-  /*  240 */ "SLIMIT",
-  /*  241 */ "SOFFSET",
-  /*  242 */ "LIMIT",
-  /*  243 */ "OFFSET",
-  /*  244 */ "ASC",
-  /*  245 */ "NULLS",
-  /*  246 */ "ID",
-  /*  247 */ "NK_BITNOT",
-  /*  248 */ "INSERT",
+  /*  190 */ "INSERT",
+  /*  191 */ "NULL",
+  /*  192 */ "NK_QUESTION",
+  /*  193 */ "NK_ARROW",
+  /*  194 */ "ROWTS",
+  /*  195 */ "TBNAME",
+  /*  196 */ "QSTARTTS",
+  /*  197 */ "QENDTS",
+  /*  198 */ "WSTARTTS",
+  /*  199 */ "WENDTS",
+  /*  200 */ "WDURATION",
+  /*  201 */ "CAST",
+  /*  202 */ "NOW",
+  /*  203 */ "TODAY",
+  /*  204 */ "TIMEZONE",
+  /*  205 */ "CLIENT_VERSION",
+  /*  206 */ "SERVER_VERSION",
+  /*  207 */ "SERVER_STATUS",
+  /*  208 */ "CURRENT_USER",
+  /*  209 */ "COUNT",
+  /*  210 */ "LAST_ROW",
+  /*  211 */ "BETWEEN",
+  /*  212 */ "IS",
+  /*  213 */ "NK_LT",
+  /*  214 */ "NK_GT",
+  /*  215 */ "NK_LE",
+  /*  216 */ "NK_GE",
+  /*  217 */ "NK_NE",
+  /*  218 */ "MATCH",
+  /*  219 */ "NMATCH",
+  /*  220 */ "CONTAINS",
+  /*  221 */ "JOIN",
+  /*  222 */ "INNER",
+  /*  223 */ "SELECT",
+  /*  224 */ "DISTINCT",
+  /*  225 */ "WHERE",
+  /*  226 */ "PARTITION",
+  /*  227 */ "BY",
+  /*  228 */ "SESSION",
+  /*  229 */ "STATE_WINDOW",
+  /*  230 */ "SLIDING",
+  /*  231 */ "FILL",
+  /*  232 */ "VALUE",
+  /*  233 */ "NONE",
+  /*  234 */ "PREV",
+  /*  235 */ "LINEAR",
+  /*  236 */ "NEXT",
+  /*  237 */ "HAVING",
+  /*  238 */ "RANGE",
+  /*  239 */ "EVERY",
+  /*  240 */ "ORDER",
+  /*  241 */ "SLIMIT",
+  /*  242 */ "SOFFSET",
+  /*  243 */ "LIMIT",
+  /*  244 */ "OFFSET",
+  /*  245 */ "ASC",
+  /*  246 */ "NULLS",
+  /*  247 */ "ID",
+  /*  248 */ "NK_BITNOT",
   /*  249 */ "VALUES",
   /*  250 */ "IMPORT",
   /*  251 */ "NK_SEMI",
@@ -1521,7 +1515,7 @@ static const char *const yyTokenName[] = {
   /*  285 */ "type_name",
   /*  286 */ "signed_literal",
   /*  287 */ "create_subtable_clause",
-  /*  288 */ "specific_tags_opt",
+  /*  288 */ "specific_cols_opt",
   /*  289 */ "expression_list",
   /*  290 */ "drop_table_clause",
   /*  291 */ "col_name_list",
@@ -1745,12 +1739,12 @@ static const char *const yyRuleName[] = {
  /* 126 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal",
  /* 127 */ "multi_create_clause ::= create_subtable_clause",
  /* 128 */ "multi_create_clause ::= multi_create_clause create_subtable_clause",
- /* 129 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP expression_list NK_RP table_options",
+ /* 129 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options",
  /* 130 */ "multi_drop_clause ::= drop_table_clause",
  /* 131 */ "multi_drop_clause ::= multi_drop_clause drop_table_clause",
  /* 132 */ "drop_table_clause ::= exists_opt full_table_name",
- /* 133 */ "specific_tags_opt ::=",
- /* 134 */ "specific_tags_opt ::= NK_LP col_name_list NK_RP",
+ /* 133 */ "specific_cols_opt ::=",
+ /* 134 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP",
  /* 135 */ "full_table_name ::= table_name",
  /* 136 */ "full_table_name ::= db_name NK_DOT table_name",
  /* 137 */ "column_def_list ::= column_def",
@@ -1899,207 +1893,208 @@ static const char *const yyRuleName[] = {
  /* 280 */ "cmd ::= SYNCDB db_name REPLICA",
  /* 281 */ "cmd ::= DELETE FROM full_table_name where_clause_opt",
  /* 282 */ "cmd ::= query_expression",
- /* 283 */ "literal ::= NK_INTEGER",
- /* 284 */ "literal ::= NK_FLOAT",
- /* 285 */ "literal ::= NK_STRING",
- /* 286 */ "literal ::= NK_BOOL",
- /* 287 */ "literal ::= TIMESTAMP NK_STRING",
- /* 288 */ "literal ::= duration_literal",
- /* 289 */ "literal ::= NULL",
- /* 290 */ "literal ::= NK_QUESTION",
- /* 291 */ "duration_literal ::= NK_VARIABLE",
- /* 292 */ "signed ::= NK_INTEGER",
- /* 293 */ "signed ::= NK_PLUS NK_INTEGER",
- /* 294 */ "signed ::= NK_MINUS NK_INTEGER",
- /* 295 */ "signed ::= NK_FLOAT",
- /* 296 */ "signed ::= NK_PLUS NK_FLOAT",
- /* 297 */ "signed ::= NK_MINUS NK_FLOAT",
- /* 298 */ "signed_literal ::= signed",
- /* 299 */ "signed_literal ::= NK_STRING",
- /* 300 */ "signed_literal ::= NK_BOOL",
- /* 301 */ "signed_literal ::= TIMESTAMP NK_STRING",
- /* 302 */ "signed_literal ::= duration_literal",
- /* 303 */ "signed_literal ::= NULL",
- /* 304 */ "signed_literal ::= literal_func",
- /* 305 */ "literal_list ::= signed_literal",
- /* 306 */ "literal_list ::= literal_list NK_COMMA signed_literal",
- /* 307 */ "db_name ::= NK_ID",
- /* 308 */ "table_name ::= NK_ID",
- /* 309 */ "column_name ::= NK_ID",
- /* 310 */ "function_name ::= NK_ID",
- /* 311 */ "table_alias ::= NK_ID",
- /* 312 */ "column_alias ::= NK_ID",
- /* 313 */ "user_name ::= NK_ID",
- /* 314 */ "index_name ::= NK_ID",
- /* 315 */ "topic_name ::= NK_ID",
- /* 316 */ "stream_name ::= NK_ID",
- /* 317 */ "cgroup_name ::= NK_ID",
- /* 318 */ "expression ::= literal",
- /* 319 */ "expression ::= pseudo_column",
- /* 320 */ "expression ::= column_reference",
- /* 321 */ "expression ::= function_expression",
- /* 322 */ "expression ::= subquery",
- /* 323 */ "expression ::= NK_LP expression NK_RP",
- /* 324 */ "expression ::= NK_PLUS expression",
- /* 325 */ "expression ::= NK_MINUS expression",
- /* 326 */ "expression ::= expression NK_PLUS expression",
- /* 327 */ "expression ::= expression NK_MINUS expression",
- /* 328 */ "expression ::= expression NK_STAR expression",
- /* 329 */ "expression ::= expression NK_SLASH expression",
- /* 330 */ "expression ::= expression NK_REM expression",
- /* 331 */ "expression ::= column_reference NK_ARROW NK_STRING",
- /* 332 */ "expression ::= expression NK_BITAND expression",
- /* 333 */ "expression ::= expression NK_BITOR expression",
- /* 334 */ "expression_list ::= expression",
- /* 335 */ "expression_list ::= expression_list NK_COMMA expression",
- /* 336 */ "column_reference ::= column_name",
- /* 337 */ "column_reference ::= table_name NK_DOT column_name",
- /* 338 */ "pseudo_column ::= ROWTS",
- /* 339 */ "pseudo_column ::= TBNAME",
- /* 340 */ "pseudo_column ::= table_name NK_DOT TBNAME",
- /* 341 */ "pseudo_column ::= QSTARTTS",
- /* 342 */ "pseudo_column ::= QENDTS",
- /* 343 */ "pseudo_column ::= WSTARTTS",
- /* 344 */ "pseudo_column ::= WENDTS",
- /* 345 */ "pseudo_column ::= WDURATION",
- /* 346 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
- /* 347 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
- /* 348 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
- /* 349 */ "function_expression ::= literal_func",
- /* 350 */ "literal_func ::= noarg_func NK_LP NK_RP",
- /* 351 */ "literal_func ::= NOW",
- /* 352 */ "noarg_func ::= NOW",
- /* 353 */ "noarg_func ::= TODAY",
- /* 354 */ "noarg_func ::= TIMEZONE",
- /* 355 */ "noarg_func ::= DATABASE",
- /* 356 */ "noarg_func ::= CLIENT_VERSION",
- /* 357 */ "noarg_func ::= SERVER_VERSION",
- /* 358 */ "noarg_func ::= SERVER_STATUS",
- /* 359 */ "noarg_func ::= CURRENT_USER",
- /* 360 */ "noarg_func ::= USER",
- /* 361 */ "star_func ::= COUNT",
- /* 362 */ "star_func ::= FIRST",
- /* 363 */ "star_func ::= LAST",
- /* 364 */ "star_func ::= LAST_ROW",
- /* 365 */ "star_func_para_list ::= NK_STAR",
- /* 366 */ "star_func_para_list ::= other_para_list",
- /* 367 */ "other_para_list ::= star_func_para",
- /* 368 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
- /* 369 */ "star_func_para ::= expression",
- /* 370 */ "star_func_para ::= table_name NK_DOT NK_STAR",
- /* 371 */ "predicate ::= expression compare_op expression",
- /* 372 */ "predicate ::= expression BETWEEN expression AND expression",
- /* 373 */ "predicate ::= expression NOT BETWEEN expression AND expression",
- /* 374 */ "predicate ::= expression IS NULL",
- /* 375 */ "predicate ::= expression IS NOT NULL",
- /* 376 */ "predicate ::= expression in_op in_predicate_value",
- /* 377 */ "compare_op ::= NK_LT",
- /* 378 */ "compare_op ::= NK_GT",
- /* 379 */ "compare_op ::= NK_LE",
- /* 380 */ "compare_op ::= NK_GE",
- /* 381 */ "compare_op ::= NK_NE",
- /* 382 */ "compare_op ::= NK_EQ",
- /* 383 */ "compare_op ::= LIKE",
- /* 384 */ "compare_op ::= NOT LIKE",
- /* 385 */ "compare_op ::= MATCH",
- /* 386 */ "compare_op ::= NMATCH",
- /* 387 */ "compare_op ::= CONTAINS",
- /* 388 */ "in_op ::= IN",
- /* 389 */ "in_op ::= NOT IN",
- /* 390 */ "in_predicate_value ::= NK_LP expression_list NK_RP",
- /* 391 */ "boolean_value_expression ::= boolean_primary",
- /* 392 */ "boolean_value_expression ::= NOT boolean_primary",
- /* 393 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
- /* 394 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
- /* 395 */ "boolean_primary ::= predicate",
- /* 396 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
- /* 397 */ "common_expression ::= expression",
- /* 398 */ "common_expression ::= boolean_value_expression",
- /* 399 */ "from_clause_opt ::=",
- /* 400 */ "from_clause_opt ::= FROM table_reference_list",
- /* 401 */ "table_reference_list ::= table_reference",
- /* 402 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
- /* 403 */ "table_reference ::= table_primary",
- /* 404 */ "table_reference ::= joined_table",
- /* 405 */ "table_primary ::= table_name alias_opt",
- /* 406 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
- /* 407 */ "table_primary ::= subquery alias_opt",
- /* 408 */ "table_primary ::= parenthesized_joined_table",
- /* 409 */ "alias_opt ::=",
- /* 410 */ "alias_opt ::= table_alias",
- /* 411 */ "alias_opt ::= AS table_alias",
- /* 412 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
- /* 413 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
- /* 414 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
- /* 415 */ "join_type ::=",
- /* 416 */ "join_type ::= INNER",
- /* 417 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
- /* 418 */ "set_quantifier_opt ::=",
- /* 419 */ "set_quantifier_opt ::= DISTINCT",
- /* 420 */ "set_quantifier_opt ::= ALL",
- /* 421 */ "select_list ::= select_item",
- /* 422 */ "select_list ::= select_list NK_COMMA select_item",
- /* 423 */ "select_item ::= NK_STAR",
- /* 424 */ "select_item ::= common_expression",
- /* 425 */ "select_item ::= common_expression column_alias",
- /* 426 */ "select_item ::= common_expression AS column_alias",
- /* 427 */ "select_item ::= table_name NK_DOT NK_STAR",
- /* 428 */ "where_clause_opt ::=",
- /* 429 */ "where_clause_opt ::= WHERE search_condition",
- /* 430 */ "partition_by_clause_opt ::=",
- /* 431 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
- /* 432 */ "twindow_clause_opt ::=",
- /* 433 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
- /* 434 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
- /* 435 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
- /* 436 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
- /* 437 */ "sliding_opt ::=",
- /* 438 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
- /* 439 */ "fill_opt ::=",
- /* 440 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
- /* 441 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
- /* 442 */ "fill_mode ::= NONE",
- /* 443 */ "fill_mode ::= PREV",
- /* 444 */ "fill_mode ::= NULL",
- /* 445 */ "fill_mode ::= LINEAR",
- /* 446 */ "fill_mode ::= NEXT",
- /* 447 */ "group_by_clause_opt ::=",
- /* 448 */ "group_by_clause_opt ::= GROUP BY group_by_list",
- /* 449 */ "group_by_list ::= expression",
- /* 450 */ "group_by_list ::= group_by_list NK_COMMA expression",
- /* 451 */ "having_clause_opt ::=",
- /* 452 */ "having_clause_opt ::= HAVING search_condition",
- /* 453 */ "range_opt ::=",
- /* 454 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
- /* 455 */ "every_opt ::=",
- /* 456 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
- /* 457 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
- /* 458 */ "query_expression_body ::= query_primary",
- /* 459 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
- /* 460 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
- /* 461 */ "query_primary ::= query_specification",
- /* 462 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
- /* 463 */ "order_by_clause_opt ::=",
- /* 464 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 465 */ "slimit_clause_opt ::=",
- /* 466 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 467 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 468 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 469 */ "limit_clause_opt ::=",
- /* 470 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 471 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 472 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 473 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 474 */ "search_condition ::= common_expression",
- /* 475 */ "sort_specification_list ::= sort_specification",
- /* 476 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 477 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
- /* 478 */ "ordering_specification_opt ::=",
- /* 479 */ "ordering_specification_opt ::= ASC",
- /* 480 */ "ordering_specification_opt ::= DESC",
- /* 481 */ "null_ordering_opt ::=",
- /* 482 */ "null_ordering_opt ::= NULLS FIRST",
- /* 483 */ "null_ordering_opt ::= NULLS LAST",
+ /* 283 */ "cmd ::= INSERT INTO full_table_name specific_cols_opt query_expression",
+ /* 284 */ "literal ::= NK_INTEGER",
+ /* 285 */ "literal ::= NK_FLOAT",
+ /* 286 */ "literal ::= NK_STRING",
+ /* 287 */ "literal ::= NK_BOOL",
+ /* 288 */ "literal ::= TIMESTAMP NK_STRING",
+ /* 289 */ "literal ::= duration_literal",
+ /* 290 */ "literal ::= NULL",
+ /* 291 */ "literal ::= NK_QUESTION",
+ /* 292 */ "duration_literal ::= NK_VARIABLE",
+ /* 293 */ "signed ::= NK_INTEGER",
+ /* 294 */ "signed ::= NK_PLUS NK_INTEGER",
+ /* 295 */ "signed ::= NK_MINUS NK_INTEGER",
+ /* 296 */ "signed ::= NK_FLOAT",
+ /* 297 */ "signed ::= NK_PLUS NK_FLOAT",
+ /* 298 */ "signed ::= NK_MINUS NK_FLOAT",
+ /* 299 */ "signed_literal ::= signed",
+ /* 300 */ "signed_literal ::= NK_STRING",
+ /* 301 */ "signed_literal ::= NK_BOOL",
+ /* 302 */ "signed_literal ::= TIMESTAMP NK_STRING",
+ /* 303 */ "signed_literal ::= duration_literal",
+ /* 304 */ "signed_literal ::= NULL",
+ /* 305 */ "signed_literal ::= literal_func",
+ /* 306 */ "literal_list ::= signed_literal",
+ /* 307 */ "literal_list ::= literal_list NK_COMMA signed_literal",
+ /* 308 */ "db_name ::= NK_ID",
+ /* 309 */ "table_name ::= NK_ID",
+ /* 310 */ "column_name ::= NK_ID",
+ /* 311 */ "function_name ::= NK_ID",
+ /* 312 */ "table_alias ::= NK_ID",
+ /* 313 */ "column_alias ::= NK_ID",
+ /* 314 */ "user_name ::= NK_ID",
+ /* 315 */ "index_name ::= NK_ID",
+ /* 316 */ "topic_name ::= NK_ID",
+ /* 317 */ "stream_name ::= NK_ID",
+ /* 318 */ "cgroup_name ::= NK_ID",
+ /* 319 */ "expression ::= literal",
+ /* 320 */ "expression ::= pseudo_column",
+ /* 321 */ "expression ::= column_reference",
+ /* 322 */ "expression ::= function_expression",
+ /* 323 */ "expression ::= subquery",
+ /* 324 */ "expression ::= NK_LP expression NK_RP",
+ /* 325 */ "expression ::= NK_PLUS expression",
+ /* 326 */ "expression ::= NK_MINUS expression",
+ /* 327 */ "expression ::= expression NK_PLUS expression",
+ /* 328 */ "expression ::= expression NK_MINUS expression",
+ /* 329 */ "expression ::= expression NK_STAR expression",
+ /* 330 */ "expression ::= expression NK_SLASH expression",
+ /* 331 */ "expression ::= expression NK_REM expression",
+ /* 332 */ "expression ::= column_reference NK_ARROW NK_STRING",
+ /* 333 */ "expression ::= expression NK_BITAND expression",
+ /* 334 */ "expression ::= expression NK_BITOR expression",
+ /* 335 */ "expression_list ::= expression",
+ /* 336 */ "expression_list ::= expression_list NK_COMMA expression",
+ /* 337 */ "column_reference ::= column_name",
+ /* 338 */ "column_reference ::= table_name NK_DOT column_name",
+ /* 339 */ "pseudo_column ::= ROWTS",
+ /* 340 */ "pseudo_column ::= TBNAME",
+ /* 341 */ "pseudo_column ::= table_name NK_DOT TBNAME",
+ /* 342 */ "pseudo_column ::= QSTARTTS",
+ /* 343 */ "pseudo_column ::= QENDTS",
+ /* 344 */ "pseudo_column ::= WSTARTTS",
+ /* 345 */ "pseudo_column ::= WENDTS",
+ /* 346 */ "pseudo_column ::= WDURATION",
+ /* 347 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
+ /* 348 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
+ /* 349 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
+ /* 350 */ "function_expression ::= literal_func",
+ /* 351 */ "literal_func ::= noarg_func NK_LP NK_RP",
+ /* 352 */ "literal_func ::= NOW",
+ /* 353 */ "noarg_func ::= NOW",
+ /* 354 */ "noarg_func ::= TODAY",
+ /* 355 */ "noarg_func ::= TIMEZONE",
+ /* 356 */ "noarg_func ::= DATABASE",
+ /* 357 */ "noarg_func ::= CLIENT_VERSION",
+ /* 358 */ "noarg_func ::= SERVER_VERSION",
+ /* 359 */ "noarg_func ::= SERVER_STATUS",
+ /* 360 */ "noarg_func ::= CURRENT_USER",
+ /* 361 */ "noarg_func ::= USER",
+ /* 362 */ "star_func ::= COUNT",
+ /* 363 */ "star_func ::= FIRST",
+ /* 364 */ "star_func ::= LAST",
+ /* 365 */ "star_func ::= LAST_ROW",
+ /* 366 */ "star_func_para_list ::= NK_STAR",
+ /* 367 */ "star_func_para_list ::= other_para_list",
+ /* 368 */ "other_para_list ::= star_func_para",
+ /* 369 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
+ /* 370 */ "star_func_para ::= expression",
+ /* 371 */ "star_func_para ::= table_name NK_DOT NK_STAR",
+ /* 372 */ "predicate ::= expression compare_op expression",
+ /* 373 */ "predicate ::= expression BETWEEN expression AND expression",
+ /* 374 */ "predicate ::= expression NOT BETWEEN expression AND expression",
+ /* 375 */ "predicate ::= expression IS NULL",
+ /* 376 */ "predicate ::= expression IS NOT NULL",
+ /* 377 */ "predicate ::= expression in_op in_predicate_value",
+ /* 378 */ "compare_op ::= NK_LT",
+ /* 379 */ "compare_op ::= NK_GT",
+ /* 380 */ "compare_op ::= NK_LE",
+ /* 381 */ "compare_op ::= NK_GE",
+ /* 382 */ "compare_op ::= NK_NE",
+ /* 383 */ "compare_op ::= NK_EQ",
+ /* 384 */ "compare_op ::= LIKE",
+ /* 385 */ "compare_op ::= NOT LIKE",
+ /* 386 */ "compare_op ::= MATCH",
+ /* 387 */ "compare_op ::= NMATCH",
+ /* 388 */ "compare_op ::= CONTAINS",
+ /* 389 */ "in_op ::= IN",
+ /* 390 */ "in_op ::= NOT IN",
+ /* 391 */ "in_predicate_value ::= NK_LP expression_list NK_RP",
+ /* 392 */ "boolean_value_expression ::= boolean_primary",
+ /* 393 */ "boolean_value_expression ::= NOT boolean_primary",
+ /* 394 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
+ /* 395 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
+ /* 396 */ "boolean_primary ::= predicate",
+ /* 397 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
+ /* 398 */ "common_expression ::= expression",
+ /* 399 */ "common_expression ::= boolean_value_expression",
+ /* 400 */ "from_clause_opt ::=",
+ /* 401 */ "from_clause_opt ::= FROM table_reference_list",
+ /* 402 */ "table_reference_list ::= table_reference",
+ /* 403 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
+ /* 404 */ "table_reference ::= table_primary",
+ /* 405 */ "table_reference ::= joined_table",
+ /* 406 */ "table_primary ::= table_name alias_opt",
+ /* 407 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
+ /* 408 */ "table_primary ::= subquery alias_opt",
+ /* 409 */ "table_primary ::= parenthesized_joined_table",
+ /* 410 */ "alias_opt ::=",
+ /* 411 */ "alias_opt ::= table_alias",
+ /* 412 */ "alias_opt ::= AS table_alias",
+ /* 413 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
+ /* 414 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
+ /* 415 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
+ /* 416 */ "join_type ::=",
+ /* 417 */ "join_type ::= INNER",
+ /* 418 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
+ /* 419 */ "set_quantifier_opt ::=",
+ /* 420 */ "set_quantifier_opt ::= DISTINCT",
+ /* 421 */ "set_quantifier_opt ::= ALL",
+ /* 422 */ "select_list ::= select_item",
+ /* 423 */ "select_list ::= select_list NK_COMMA select_item",
+ /* 424 */ "select_item ::= NK_STAR",
+ /* 425 */ "select_item ::= common_expression",
+ /* 426 */ "select_item ::= common_expression column_alias",
+ /* 427 */ "select_item ::= common_expression AS column_alias",
+ /* 428 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /* 429 */ "where_clause_opt ::=",
+ /* 430 */ "where_clause_opt ::= WHERE search_condition",
+ /* 431 */ "partition_by_clause_opt ::=",
+ /* 432 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
+ /* 433 */ "twindow_clause_opt ::=",
+ /* 434 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
+ /* 435 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
+ /* 436 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
+ /* 437 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
+ /* 438 */ "sliding_opt ::=",
+ /* 439 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
+ /* 440 */ "fill_opt ::=",
+ /* 441 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
+ /* 442 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
+ /* 443 */ "fill_mode ::= NONE",
+ /* 444 */ "fill_mode ::= PREV",
+ /* 445 */ "fill_mode ::= NULL",
+ /* 446 */ "fill_mode ::= LINEAR",
+ /* 447 */ "fill_mode ::= NEXT",
+ /* 448 */ "group_by_clause_opt ::=",
+ /* 449 */ "group_by_clause_opt ::= GROUP BY group_by_list",
+ /* 450 */ "group_by_list ::= expression",
+ /* 451 */ "group_by_list ::= group_by_list NK_COMMA expression",
+ /* 452 */ "having_clause_opt ::=",
+ /* 453 */ "having_clause_opt ::= HAVING search_condition",
+ /* 454 */ "range_opt ::=",
+ /* 455 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
+ /* 456 */ "every_opt ::=",
+ /* 457 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
+ /* 458 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /* 459 */ "query_expression_body ::= query_primary",
+ /* 460 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
+ /* 461 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
+ /* 462 */ "query_primary ::= query_specification",
+ /* 463 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
+ /* 464 */ "order_by_clause_opt ::=",
+ /* 465 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 466 */ "slimit_clause_opt ::=",
+ /* 467 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 468 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 469 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 470 */ "limit_clause_opt ::=",
+ /* 471 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 472 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 473 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 474 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 475 */ "search_condition ::= common_expression",
+ /* 476 */ "sort_specification_list ::= sort_specification",
+ /* 477 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 478 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
+ /* 479 */ "ordering_specification_opt ::=",
+ /* 480 */ "ordering_specification_opt ::= ASC",
+ /* 481 */ "ordering_specification_opt ::= DESC",
+ /* 482 */ "null_ordering_opt ::=",
+ /* 483 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 484 */ "null_ordering_opt ::= NULLS LAST",
 };
 #endif /* NDEBUG */
 
@@ -2348,7 +2343,7 @@ static void yy_destructor(
     case 279: /* multi_create_clause */
     case 280: /* tags_def */
     case 281: /* multi_drop_clause */
-    case 288: /* specific_tags_opt */
+    case 288: /* specific_cols_opt */
     case 289: /* expression_list */
     case 291: /* col_name_list */
     case 294: /* duration_list */
@@ -2828,12 +2823,12 @@ static const struct {
   {  282,   -6 }, /* (126) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
   {  279,   -1 }, /* (127) multi_create_clause ::= create_subtable_clause */
   {  279,   -2 }, /* (128) multi_create_clause ::= multi_create_clause create_subtable_clause */
-  {  287,  -10 }, /* (129) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP expression_list NK_RP table_options */
+  {  287,  -10 }, /* (129) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */
   {  281,   -1 }, /* (130) multi_drop_clause ::= drop_table_clause */
   {  281,   -2 }, /* (131) multi_drop_clause ::= multi_drop_clause drop_table_clause */
   {  290,   -2 }, /* (132) drop_table_clause ::= exists_opt full_table_name */
-  {  288,    0 }, /* (133) specific_tags_opt ::= */
-  {  288,   -3 }, /* (134) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+  {  288,    0 }, /* (133) specific_cols_opt ::= */
+  {  288,   -3 }, /* (134) specific_cols_opt ::= NK_LP col_name_list NK_RP */
   {  275,   -1 }, /* (135) full_table_name ::= table_name */
   {  275,   -3 }, /* (136) full_table_name ::= db_name NK_DOT table_name */
   {  276,   -1 }, /* (137) column_def_list ::= column_def */
@@ -2982,207 +2977,208 @@ static const struct {
   {  253,   -3 }, /* (280) cmd ::= SYNCDB db_name REPLICA */
   {  253,   -4 }, /* (281) cmd ::= DELETE FROM full_table_name where_clause_opt */
   {  253,   -1 }, /* (282) cmd ::= query_expression */
-  {  256,   -1 }, /* (283) literal ::= NK_INTEGER */
-  {  256,   -1 }, /* (284) literal ::= NK_FLOAT */
-  {  256,   -1 }, /* (285) literal ::= NK_STRING */
-  {  256,   -1 }, /* (286) literal ::= NK_BOOL */
-  {  256,   -2 }, /* (287) literal ::= TIMESTAMP NK_STRING */
-  {  256,   -1 }, /* (288) literal ::= duration_literal */
-  {  256,   -1 }, /* (289) literal ::= NULL */
-  {  256,   -1 }, /* (290) literal ::= NK_QUESTION */
-  {  297,   -1 }, /* (291) duration_literal ::= NK_VARIABLE */
-  {  323,   -1 }, /* (292) signed ::= NK_INTEGER */
-  {  323,   -2 }, /* (293) signed ::= NK_PLUS NK_INTEGER */
-  {  323,   -2 }, /* (294) signed ::= NK_MINUS NK_INTEGER */
-  {  323,   -1 }, /* (295) signed ::= NK_FLOAT */
-  {  323,   -2 }, /* (296) signed ::= NK_PLUS NK_FLOAT */
-  {  323,   -2 }, /* (297) signed ::= NK_MINUS NK_FLOAT */
-  {  286,   -1 }, /* (298) signed_literal ::= signed */
-  {  286,   -1 }, /* (299) signed_literal ::= NK_STRING */
-  {  286,   -1 }, /* (300) signed_literal ::= NK_BOOL */
-  {  286,   -2 }, /* (301) signed_literal ::= TIMESTAMP NK_STRING */
-  {  286,   -1 }, /* (302) signed_literal ::= duration_literal */
-  {  286,   -1 }, /* (303) signed_literal ::= NULL */
-  {  286,   -1 }, /* (304) signed_literal ::= literal_func */
-  {  325,   -1 }, /* (305) literal_list ::= signed_literal */
-  {  325,   -3 }, /* (306) literal_list ::= literal_list NK_COMMA signed_literal */
-  {  264,   -1 }, /* (307) db_name ::= NK_ID */
-  {  292,   -1 }, /* (308) table_name ::= NK_ID */
-  {  284,   -1 }, /* (309) column_name ::= NK_ID */
-  {  299,   -1 }, /* (310) function_name ::= NK_ID */
-  {  326,   -1 }, /* (311) table_alias ::= NK_ID */
-  {  327,   -1 }, /* (312) column_alias ::= NK_ID */
-  {  258,   -1 }, /* (313) user_name ::= NK_ID */
-  {  305,   -1 }, /* (314) index_name ::= NK_ID */
-  {  312,   -1 }, /* (315) topic_name ::= NK_ID */
-  {  319,   -1 }, /* (316) stream_name ::= NK_ID */
-  {  314,   -1 }, /* (317) cgroup_name ::= NK_ID */
-  {  328,   -1 }, /* (318) expression ::= literal */
-  {  328,   -1 }, /* (319) expression ::= pseudo_column */
-  {  328,   -1 }, /* (320) expression ::= column_reference */
-  {  328,   -1 }, /* (321) expression ::= function_expression */
-  {  328,   -1 }, /* (322) expression ::= subquery */
-  {  328,   -3 }, /* (323) expression ::= NK_LP expression NK_RP */
-  {  328,   -2 }, /* (324) expression ::= NK_PLUS expression */
-  {  328,   -2 }, /* (325) expression ::= NK_MINUS expression */
-  {  328,   -3 }, /* (326) expression ::= expression NK_PLUS expression */
-  {  328,   -3 }, /* (327) expression ::= expression NK_MINUS expression */
-  {  328,   -3 }, /* (328) expression ::= expression NK_STAR expression */
-  {  328,   -3 }, /* (329) expression ::= expression NK_SLASH expression */
-  {  328,   -3 }, /* (330) expression ::= expression NK_REM expression */
-  {  328,   -3 }, /* (331) expression ::= column_reference NK_ARROW NK_STRING */
-  {  328,   -3 }, /* (332) expression ::= expression NK_BITAND expression */
-  {  328,   -3 }, /* (333) expression ::= expression NK_BITOR expression */
-  {  289,   -1 }, /* (334) expression_list ::= expression */
-  {  289,   -3 }, /* (335) expression_list ::= expression_list NK_COMMA expression */
-  {  330,   -1 }, /* (336) column_reference ::= column_name */
-  {  330,   -3 }, /* (337) column_reference ::= table_name NK_DOT column_name */
-  {  329,   -1 }, /* (338) pseudo_column ::= ROWTS */
-  {  329,   -1 }, /* (339) pseudo_column ::= TBNAME */
-  {  329,   -3 }, /* (340) pseudo_column ::= table_name NK_DOT TBNAME */
-  {  329,   -1 }, /* (341) pseudo_column ::= QSTARTTS */
-  {  329,   -1 }, /* (342) pseudo_column ::= QENDTS */
-  {  329,   -1 }, /* (343) pseudo_column ::= WSTARTTS */
-  {  329,   -1 }, /* (344) pseudo_column ::= WENDTS */
-  {  329,   -1 }, /* (345) pseudo_column ::= WDURATION */
-  {  331,   -4 }, /* (346) function_expression ::= function_name NK_LP expression_list NK_RP */
-  {  331,   -4 }, /* (347) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-  {  331,   -6 }, /* (348) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
-  {  331,   -1 }, /* (349) function_expression ::= literal_func */
-  {  324,   -3 }, /* (350) literal_func ::= noarg_func NK_LP NK_RP */
-  {  324,   -1 }, /* (351) literal_func ::= NOW */
-  {  335,   -1 }, /* (352) noarg_func ::= NOW */
-  {  335,   -1 }, /* (353) noarg_func ::= TODAY */
-  {  335,   -1 }, /* (354) noarg_func ::= TIMEZONE */
-  {  335,   -1 }, /* (355) noarg_func ::= DATABASE */
-  {  335,   -1 }, /* (356) noarg_func ::= CLIENT_VERSION */
-  {  335,   -1 }, /* (357) noarg_func ::= SERVER_VERSION */
-  {  335,   -1 }, /* (358) noarg_func ::= SERVER_STATUS */
-  {  335,   -1 }, /* (359) noarg_func ::= CURRENT_USER */
-  {  335,   -1 }, /* (360) noarg_func ::= USER */
-  {  333,   -1 }, /* (361) star_func ::= COUNT */
-  {  333,   -1 }, /* (362) star_func ::= FIRST */
-  {  333,   -1 }, /* (363) star_func ::= LAST */
-  {  333,   -1 }, /* (364) star_func ::= LAST_ROW */
-  {  334,   -1 }, /* (365) star_func_para_list ::= NK_STAR */
-  {  334,   -1 }, /* (366) star_func_para_list ::= other_para_list */
-  {  336,   -1 }, /* (367) other_para_list ::= star_func_para */
-  {  336,   -3 }, /* (368) other_para_list ::= other_para_list NK_COMMA star_func_para */
-  {  337,   -1 }, /* (369) star_func_para ::= expression */
-  {  337,   -3 }, /* (370) star_func_para ::= table_name NK_DOT NK_STAR */
-  {  338,   -3 }, /* (371) predicate ::= expression compare_op expression */
-  {  338,   -5 }, /* (372) predicate ::= expression BETWEEN expression AND expression */
-  {  338,   -6 }, /* (373) predicate ::= expression NOT BETWEEN expression AND expression */
-  {  338,   -3 }, /* (374) predicate ::= expression IS NULL */
-  {  338,   -4 }, /* (375) predicate ::= expression IS NOT NULL */
-  {  338,   -3 }, /* (376) predicate ::= expression in_op in_predicate_value */
-  {  339,   -1 }, /* (377) compare_op ::= NK_LT */
-  {  339,   -1 }, /* (378) compare_op ::= NK_GT */
-  {  339,   -1 }, /* (379) compare_op ::= NK_LE */
-  {  339,   -1 }, /* (380) compare_op ::= NK_GE */
-  {  339,   -1 }, /* (381) compare_op ::= NK_NE */
-  {  339,   -1 }, /* (382) compare_op ::= NK_EQ */
-  {  339,   -1 }, /* (383) compare_op ::= LIKE */
-  {  339,   -2 }, /* (384) compare_op ::= NOT LIKE */
-  {  339,   -1 }, /* (385) compare_op ::= MATCH */
-  {  339,   -1 }, /* (386) compare_op ::= NMATCH */
-  {  339,   -1 }, /* (387) compare_op ::= CONTAINS */
-  {  340,   -1 }, /* (388) in_op ::= IN */
-  {  340,   -2 }, /* (389) in_op ::= NOT IN */
-  {  341,   -3 }, /* (390) in_predicate_value ::= NK_LP expression_list NK_RP */
-  {  342,   -1 }, /* (391) boolean_value_expression ::= boolean_primary */
-  {  342,   -2 }, /* (392) boolean_value_expression ::= NOT boolean_primary */
-  {  342,   -3 }, /* (393) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-  {  342,   -3 }, /* (394) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-  {  343,   -1 }, /* (395) boolean_primary ::= predicate */
-  {  343,   -3 }, /* (396) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-  {  344,   -1 }, /* (397) common_expression ::= expression */
-  {  344,   -1 }, /* (398) common_expression ::= boolean_value_expression */
-  {  345,    0 }, /* (399) from_clause_opt ::= */
-  {  345,   -2 }, /* (400) from_clause_opt ::= FROM table_reference_list */
-  {  346,   -1 }, /* (401) table_reference_list ::= table_reference */
-  {  346,   -3 }, /* (402) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-  {  347,   -1 }, /* (403) table_reference ::= table_primary */
-  {  347,   -1 }, /* (404) table_reference ::= joined_table */
-  {  348,   -2 }, /* (405) table_primary ::= table_name alias_opt */
-  {  348,   -4 }, /* (406) table_primary ::= db_name NK_DOT table_name alias_opt */
-  {  348,   -2 }, /* (407) table_primary ::= subquery alias_opt */
-  {  348,   -1 }, /* (408) table_primary ::= parenthesized_joined_table */
-  {  350,    0 }, /* (409) alias_opt ::= */
-  {  350,   -1 }, /* (410) alias_opt ::= table_alias */
-  {  350,   -2 }, /* (411) alias_opt ::= AS table_alias */
-  {  351,   -3 }, /* (412) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-  {  351,   -3 }, /* (413) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-  {  349,   -6 }, /* (414) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-  {  352,    0 }, /* (415) join_type ::= */
-  {  352,   -1 }, /* (416) join_type ::= INNER */
-  {  354,  -12 }, /* (417) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-  {  355,    0 }, /* (418) set_quantifier_opt ::= */
-  {  355,   -1 }, /* (419) set_quantifier_opt ::= DISTINCT */
-  {  355,   -1 }, /* (420) set_quantifier_opt ::= ALL */
-  {  356,   -1 }, /* (421) select_list ::= select_item */
-  {  356,   -3 }, /* (422) select_list ::= select_list NK_COMMA select_item */
-  {  364,   -1 }, /* (423) select_item ::= NK_STAR */
-  {  364,   -1 }, /* (424) select_item ::= common_expression */
-  {  364,   -2 }, /* (425) select_item ::= common_expression column_alias */
-  {  364,   -3 }, /* (426) select_item ::= common_expression AS column_alias */
-  {  364,   -3 }, /* (427) select_item ::= table_name NK_DOT NK_STAR */
-  {  322,    0 }, /* (428) where_clause_opt ::= */
-  {  322,   -2 }, /* (429) where_clause_opt ::= WHERE search_condition */
-  {  357,    0 }, /* (430) partition_by_clause_opt ::= */
-  {  357,   -3 }, /* (431) partition_by_clause_opt ::= PARTITION BY expression_list */
-  {  361,    0 }, /* (432) twindow_clause_opt ::= */
-  {  361,   -6 }, /* (433) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-  {  361,   -4 }, /* (434) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-  {  361,   -6 }, /* (435) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-  {  361,   -8 }, /* (436) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-  {  308,    0 }, /* (437) sliding_opt ::= */
-  {  308,   -4 }, /* (438) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-  {  360,    0 }, /* (439) fill_opt ::= */
-  {  360,   -4 }, /* (440) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-  {  360,   -6 }, /* (441) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-  {  365,   -1 }, /* (442) fill_mode ::= NONE */
-  {  365,   -1 }, /* (443) fill_mode ::= PREV */
-  {  365,   -1 }, /* (444) fill_mode ::= NULL */
-  {  365,   -1 }, /* (445) fill_mode ::= LINEAR */
-  {  365,   -1 }, /* (446) fill_mode ::= NEXT */
-  {  362,    0 }, /* (447) group_by_clause_opt ::= */
-  {  362,   -3 }, /* (448) group_by_clause_opt ::= GROUP BY group_by_list */
-  {  366,   -1 }, /* (449) group_by_list ::= expression */
-  {  366,   -3 }, /* (450) group_by_list ::= group_by_list NK_COMMA expression */
-  {  363,    0 }, /* (451) having_clause_opt ::= */
-  {  363,   -2 }, /* (452) having_clause_opt ::= HAVING search_condition */
-  {  358,    0 }, /* (453) range_opt ::= */
-  {  358,   -6 }, /* (454) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
-  {  359,    0 }, /* (455) every_opt ::= */
-  {  359,   -4 }, /* (456) every_opt ::= EVERY NK_LP duration_literal NK_RP */
-  {  313,   -4 }, /* (457) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
-  {  367,   -1 }, /* (458) query_expression_body ::= query_primary */
-  {  367,   -4 }, /* (459) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  367,   -3 }, /* (460) query_expression_body ::= query_expression_body UNION query_expression_body */
-  {  371,   -1 }, /* (461) query_primary ::= query_specification */
-  {  371,   -6 }, /* (462) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
-  {  368,    0 }, /* (463) order_by_clause_opt ::= */
-  {  368,   -3 }, /* (464) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  369,    0 }, /* (465) slimit_clause_opt ::= */
-  {  369,   -2 }, /* (466) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  369,   -4 }, /* (467) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  369,   -4 }, /* (468) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  370,    0 }, /* (469) limit_clause_opt ::= */
-  {  370,   -2 }, /* (470) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  370,   -4 }, /* (471) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  370,   -4 }, /* (472) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  332,   -3 }, /* (473) subquery ::= NK_LP query_expression NK_RP */
-  {  353,   -1 }, /* (474) search_condition ::= common_expression */
-  {  372,   -1 }, /* (475) sort_specification_list ::= sort_specification */
-  {  372,   -3 }, /* (476) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  373,   -3 }, /* (477) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  374,    0 }, /* (478) ordering_specification_opt ::= */
-  {  374,   -1 }, /* (479) ordering_specification_opt ::= ASC */
-  {  374,   -1 }, /* (480) ordering_specification_opt ::= DESC */
-  {  375,    0 }, /* (481) null_ordering_opt ::= */
-  {  375,   -2 }, /* (482) null_ordering_opt ::= NULLS FIRST */
-  {  375,   -2 }, /* (483) null_ordering_opt ::= NULLS LAST */
+  {  253,   -5 }, /* (283) cmd ::= INSERT INTO full_table_name specific_cols_opt query_expression */
+  {  256,   -1 }, /* (284) literal ::= NK_INTEGER */
+  {  256,   -1 }, /* (285) literal ::= NK_FLOAT */
+  {  256,   -1 }, /* (286) literal ::= NK_STRING */
+  {  256,   -1 }, /* (287) literal ::= NK_BOOL */
+  {  256,   -2 }, /* (288) literal ::= TIMESTAMP NK_STRING */
+  {  256,   -1 }, /* (289) literal ::= duration_literal */
+  {  256,   -1 }, /* (290) literal ::= NULL */
+  {  256,   -1 }, /* (291) literal ::= NK_QUESTION */
+  {  297,   -1 }, /* (292) duration_literal ::= NK_VARIABLE */
+  {  323,   -1 }, /* (293) signed ::= NK_INTEGER */
+  {  323,   -2 }, /* (294) signed ::= NK_PLUS NK_INTEGER */
+  {  323,   -2 }, /* (295) signed ::= NK_MINUS NK_INTEGER */
+  {  323,   -1 }, /* (296) signed ::= NK_FLOAT */
+  {  323,   -2 }, /* (297) signed ::= NK_PLUS NK_FLOAT */
+  {  323,   -2 }, /* (298) signed ::= NK_MINUS NK_FLOAT */
+  {  286,   -1 }, /* (299) signed_literal ::= signed */
+  {  286,   -1 }, /* (300) signed_literal ::= NK_STRING */
+  {  286,   -1 }, /* (301) signed_literal ::= NK_BOOL */
+  {  286,   -2 }, /* (302) signed_literal ::= TIMESTAMP NK_STRING */
+  {  286,   -1 }, /* (303) signed_literal ::= duration_literal */
+  {  286,   -1 }, /* (304) signed_literal ::= NULL */
+  {  286,   -1 }, /* (305) signed_literal ::= literal_func */
+  {  325,   -1 }, /* (306) literal_list ::= signed_literal */
+  {  325,   -3 }, /* (307) literal_list ::= literal_list NK_COMMA signed_literal */
+  {  264,   -1 }, /* (308) db_name ::= NK_ID */
+  {  292,   -1 }, /* (309) table_name ::= NK_ID */
+  {  284,   -1 }, /* (310) column_name ::= NK_ID */
+  {  299,   -1 }, /* (311) function_name ::= NK_ID */
+  {  326,   -1 }, /* (312) table_alias ::= NK_ID */
+  {  327,   -1 }, /* (313) column_alias ::= NK_ID */
+  {  258,   -1 }, /* (314) user_name ::= NK_ID */
+  {  305,   -1 }, /* (315) index_name ::= NK_ID */
+  {  312,   -1 }, /* (316) topic_name ::= NK_ID */
+  {  319,   -1 }, /* (317) stream_name ::= NK_ID */
+  {  314,   -1 }, /* (318) cgroup_name ::= NK_ID */
+  {  328,   -1 }, /* (319) expression ::= literal */
+  {  328,   -1 }, /* (320) expression ::= pseudo_column */
+  {  328,   -1 }, /* (321) expression ::= column_reference */
+  {  328,   -1 }, /* (322) expression ::= function_expression */
+  {  328,   -1 }, /* (323) expression ::= subquery */
+  {  328,   -3 }, /* (324) expression ::= NK_LP expression NK_RP */
+  {  328,   -2 }, /* (325) expression ::= NK_PLUS expression */
+  {  328,   -2 }, /* (326) expression ::= NK_MINUS expression */
+  {  328,   -3 }, /* (327) expression ::= expression NK_PLUS expression */
+  {  328,   -3 }, /* (328) expression ::= expression NK_MINUS expression */
+  {  328,   -3 }, /* (329) expression ::= expression NK_STAR expression */
+  {  328,   -3 }, /* (330) expression ::= expression NK_SLASH expression */
+  {  328,   -3 }, /* (331) expression ::= expression NK_REM expression */
+  {  328,   -3 }, /* (332) expression ::= column_reference NK_ARROW NK_STRING */
+  {  328,   -3 }, /* (333) expression ::= expression NK_BITAND expression */
+  {  328,   -3 }, /* (334) expression ::= expression NK_BITOR expression */
+  {  289,   -1 }, /* (335) expression_list ::= expression */
+  {  289,   -3 }, /* (336) expression_list ::= expression_list NK_COMMA expression */
+  {  330,   -1 }, /* (337) column_reference ::= column_name */
+  {  330,   -3 }, /* (338) column_reference ::= table_name NK_DOT column_name */
+  {  329,   -1 }, /* (339) pseudo_column ::= ROWTS */
+  {  329,   -1 }, /* (340) pseudo_column ::= TBNAME */
+  {  329,   -3 }, /* (341) pseudo_column ::= table_name NK_DOT TBNAME */
+  {  329,   -1 }, /* (342) pseudo_column ::= QSTARTTS */
+  {  329,   -1 }, /* (343) pseudo_column ::= QENDTS */
+  {  329,   -1 }, /* (344) pseudo_column ::= WSTARTTS */
+  {  329,   -1 }, /* (345) pseudo_column ::= WENDTS */
+  {  329,   -1 }, /* (346) pseudo_column ::= WDURATION */
+  {  331,   -4 }, /* (347) function_expression ::= function_name NK_LP expression_list NK_RP */
+  {  331,   -4 }, /* (348) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+  {  331,   -6 }, /* (349) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+  {  331,   -1 }, /* (350) function_expression ::= literal_func */
+  {  324,   -3 }, /* (351) literal_func ::= noarg_func NK_LP NK_RP */
+  {  324,   -1 }, /* (352) literal_func ::= NOW */
+  {  335,   -1 }, /* (353) noarg_func ::= NOW */
+  {  335,   -1 }, /* (354) noarg_func ::= TODAY */
+  {  335,   -1 }, /* (355) noarg_func ::= TIMEZONE */
+  {  335,   -1 }, /* (356) noarg_func ::= DATABASE */
+  {  335,   -1 }, /* (357) noarg_func ::= CLIENT_VERSION */
+  {  335,   -1 }, /* (358) noarg_func ::= SERVER_VERSION */
+  {  335,   -1 }, /* (359) noarg_func ::= SERVER_STATUS */
+  {  335,   -1 }, /* (360) noarg_func ::= CURRENT_USER */
+  {  335,   -1 }, /* (361) noarg_func ::= USER */
+  {  333,   -1 }, /* (362) star_func ::= COUNT */
+  {  333,   -1 }, /* (363) star_func ::= FIRST */
+  {  333,   -1 }, /* (364) star_func ::= LAST */
+  {  333,   -1 }, /* (365) star_func ::= LAST_ROW */
+  {  334,   -1 }, /* (366) star_func_para_list ::= NK_STAR */
+  {  334,   -1 }, /* (367) star_func_para_list ::= other_para_list */
+  {  336,   -1 }, /* (368) other_para_list ::= star_func_para */
+  {  336,   -3 }, /* (369) other_para_list ::= other_para_list NK_COMMA star_func_para */
+  {  337,   -1 }, /* (370) star_func_para ::= expression */
+  {  337,   -3 }, /* (371) star_func_para ::= table_name NK_DOT NK_STAR */
+  {  338,   -3 }, /* (372) predicate ::= expression compare_op expression */
+  {  338,   -5 }, /* (373) predicate ::= expression BETWEEN expression AND expression */
+  {  338,   -6 }, /* (374) predicate ::= expression NOT BETWEEN expression AND expression */
+  {  338,   -3 }, /* (375) predicate ::= expression IS NULL */
+  {  338,   -4 }, /* (376) predicate ::= expression IS NOT NULL */
+  {  338,   -3 }, /* (377) predicate ::= expression in_op in_predicate_value */
+  {  339,   -1 }, /* (378) compare_op ::= NK_LT */
+  {  339,   -1 }, /* (379) compare_op ::= NK_GT */
+  {  339,   -1 }, /* (380) compare_op ::= NK_LE */
+  {  339,   -1 }, /* (381) compare_op ::= NK_GE */
+  {  339,   -1 }, /* (382) compare_op ::= NK_NE */
+  {  339,   -1 }, /* (383) compare_op ::= NK_EQ */
+  {  339,   -1 }, /* (384) compare_op ::= LIKE */
+  {  339,   -2 }, /* (385) compare_op ::= NOT LIKE */
+  {  339,   -1 }, /* (386) compare_op ::= MATCH */
+  {  339,   -1 }, /* (387) compare_op ::= NMATCH */
+  {  339,   -1 }, /* (388) compare_op ::= CONTAINS */
+  {  340,   -1 }, /* (389) in_op ::= IN */
+  {  340,   -2 }, /* (390) in_op ::= NOT IN */
+  {  341,   -3 }, /* (391) in_predicate_value ::= NK_LP expression_list NK_RP */
+  {  342,   -1 }, /* (392) boolean_value_expression ::= boolean_primary */
+  {  342,   -2 }, /* (393) boolean_value_expression ::= NOT boolean_primary */
+  {  342,   -3 }, /* (394) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+  {  342,   -3 }, /* (395) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+  {  343,   -1 }, /* (396) boolean_primary ::= predicate */
+  {  343,   -3 }, /* (397) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+  {  344,   -1 }, /* (398) common_expression ::= expression */
+  {  344,   -1 }, /* (399) common_expression ::= boolean_value_expression */
+  {  345,    0 }, /* (400) from_clause_opt ::= */
+  {  345,   -2 }, /* (401) from_clause_opt ::= FROM table_reference_list */
+  {  346,   -1 }, /* (402) table_reference_list ::= table_reference */
+  {  346,   -3 }, /* (403) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+  {  347,   -1 }, /* (404) table_reference ::= table_primary */
+  {  347,   -1 }, /* (405) table_reference ::= joined_table */
+  {  348,   -2 }, /* (406) table_primary ::= table_name alias_opt */
+  {  348,   -4 }, /* (407) table_primary ::= db_name NK_DOT table_name alias_opt */
+  {  348,   -2 }, /* (408) table_primary ::= subquery alias_opt */
+  {  348,   -1 }, /* (409) table_primary ::= parenthesized_joined_table */
+  {  350,    0 }, /* (410) alias_opt ::= */
+  {  350,   -1 }, /* (411) alias_opt ::= table_alias */
+  {  350,   -2 }, /* (412) alias_opt ::= AS table_alias */
+  {  351,   -3 }, /* (413) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+  {  351,   -3 }, /* (414) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+  {  349,   -6 }, /* (415) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+  {  352,    0 }, /* (416) join_type ::= */
+  {  352,   -1 }, /* (417) join_type ::= INNER */
+  {  354,  -12 }, /* (418) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+  {  355,    0 }, /* (419) set_quantifier_opt ::= */
+  {  355,   -1 }, /* (420) set_quantifier_opt ::= DISTINCT */
+  {  355,   -1 }, /* (421) set_quantifier_opt ::= ALL */
+  {  356,   -1 }, /* (422) select_list ::= select_item */
+  {  356,   -3 }, /* (423) select_list ::= select_list NK_COMMA select_item */
+  {  364,   -1 }, /* (424) select_item ::= NK_STAR */
+  {  364,   -1 }, /* (425) select_item ::= common_expression */
+  {  364,   -2 }, /* (426) select_item ::= common_expression column_alias */
+  {  364,   -3 }, /* (427) select_item ::= common_expression AS column_alias */
+  {  364,   -3 }, /* (428) select_item ::= table_name NK_DOT NK_STAR */
+  {  322,    0 }, /* (429) where_clause_opt ::= */
+  {  322,   -2 }, /* (430) where_clause_opt ::= WHERE search_condition */
+  {  357,    0 }, /* (431) partition_by_clause_opt ::= */
+  {  357,   -3 }, /* (432) partition_by_clause_opt ::= PARTITION BY expression_list */
+  {  361,    0 }, /* (433) twindow_clause_opt ::= */
+  {  361,   -6 }, /* (434) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+  {  361,   -4 }, /* (435) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+  {  361,   -6 }, /* (436) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+  {  361,   -8 }, /* (437) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+  {  308,    0 }, /* (438) sliding_opt ::= */
+  {  308,   -4 }, /* (439) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+  {  360,    0 }, /* (440) fill_opt ::= */
+  {  360,   -4 }, /* (441) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+  {  360,   -6 }, /* (442) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+  {  365,   -1 }, /* (443) fill_mode ::= NONE */
+  {  365,   -1 }, /* (444) fill_mode ::= PREV */
+  {  365,   -1 }, /* (445) fill_mode ::= NULL */
+  {  365,   -1 }, /* (446) fill_mode ::= LINEAR */
+  {  365,   -1 }, /* (447) fill_mode ::= NEXT */
+  {  362,    0 }, /* (448) group_by_clause_opt ::= */
+  {  362,   -3 }, /* (449) group_by_clause_opt ::= GROUP BY group_by_list */
+  {  366,   -1 }, /* (450) group_by_list ::= expression */
+  {  366,   -3 }, /* (451) group_by_list ::= group_by_list NK_COMMA expression */
+  {  363,    0 }, /* (452) having_clause_opt ::= */
+  {  363,   -2 }, /* (453) having_clause_opt ::= HAVING search_condition */
+  {  358,    0 }, /* (454) range_opt ::= */
+  {  358,   -6 }, /* (455) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+  {  359,    0 }, /* (456) every_opt ::= */
+  {  359,   -4 }, /* (457) every_opt ::= EVERY NK_LP duration_literal NK_RP */
+  {  313,   -4 }, /* (458) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+  {  367,   -1 }, /* (459) query_expression_body ::= query_primary */
+  {  367,   -4 }, /* (460) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+  {  367,   -3 }, /* (461) query_expression_body ::= query_expression_body UNION query_expression_body */
+  {  371,   -1 }, /* (462) query_primary ::= query_specification */
+  {  371,   -6 }, /* (463) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+  {  368,    0 }, /* (464) order_by_clause_opt ::= */
+  {  368,   -3 }, /* (465) order_by_clause_opt ::= ORDER BY sort_specification_list */
+  {  369,    0 }, /* (466) slimit_clause_opt ::= */
+  {  369,   -2 }, /* (467) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+  {  369,   -4 }, /* (468) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+  {  369,   -4 }, /* (469) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  370,    0 }, /* (470) limit_clause_opt ::= */
+  {  370,   -2 }, /* (471) limit_clause_opt ::= LIMIT NK_INTEGER */
+  {  370,   -4 }, /* (472) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+  {  370,   -4 }, /* (473) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  332,   -3 }, /* (474) subquery ::= NK_LP query_expression NK_RP */
+  {  353,   -1 }, /* (475) search_condition ::= common_expression */
+  {  372,   -1 }, /* (476) sort_specification_list ::= sort_specification */
+  {  372,   -3 }, /* (477) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+  {  373,   -3 }, /* (478) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+  {  374,    0 }, /* (479) ordering_specification_opt ::= */
+  {  374,   -1 }, /* (480) ordering_specification_opt ::= ASC */
+  {  374,   -1 }, /* (481) ordering_specification_opt ::= DESC */
+  {  375,    0 }, /* (482) null_ordering_opt ::= */
+  {  375,   -2 }, /* (483) null_ordering_opt ::= NULLS FIRST */
+  {  375,   -2 }, /* (484) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -3398,30 +3394,30 @@ static YYACTIONTYPE yy_reduce(
       case 49: /* dnode_endpoint ::= NK_STRING */
       case 50: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==50);
       case 51: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==51);
-      case 307: /* db_name ::= NK_ID */ yytestcase(yyruleno==307);
-      case 308: /* table_name ::= NK_ID */ yytestcase(yyruleno==308);
-      case 309: /* column_name ::= NK_ID */ yytestcase(yyruleno==309);
-      case 310: /* function_name ::= NK_ID */ yytestcase(yyruleno==310);
-      case 311: /* table_alias ::= NK_ID */ yytestcase(yyruleno==311);
-      case 312: /* column_alias ::= NK_ID */ yytestcase(yyruleno==312);
-      case 313: /* user_name ::= NK_ID */ yytestcase(yyruleno==313);
-      case 314: /* index_name ::= NK_ID */ yytestcase(yyruleno==314);
-      case 315: /* topic_name ::= NK_ID */ yytestcase(yyruleno==315);
-      case 316: /* stream_name ::= NK_ID */ yytestcase(yyruleno==316);
-      case 317: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==317);
-      case 352: /* noarg_func ::= NOW */ yytestcase(yyruleno==352);
-      case 353: /* noarg_func ::= TODAY */ yytestcase(yyruleno==353);
-      case 354: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==354);
-      case 355: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==355);
-      case 356: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==356);
-      case 357: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==357);
-      case 358: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==358);
-      case 359: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==359);
-      case 360: /* noarg_func ::= USER */ yytestcase(yyruleno==360);
-      case 361: /* star_func ::= COUNT */ yytestcase(yyruleno==361);
-      case 362: /* star_func ::= FIRST */ yytestcase(yyruleno==362);
-      case 363: /* star_func ::= LAST */ yytestcase(yyruleno==363);
-      case 364: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==364);
+      case 308: /* db_name ::= NK_ID */ yytestcase(yyruleno==308);
+      case 309: /* table_name ::= NK_ID */ yytestcase(yyruleno==309);
+      case 310: /* column_name ::= NK_ID */ yytestcase(yyruleno==310);
+      case 311: /* function_name ::= NK_ID */ yytestcase(yyruleno==311);
+      case 312: /* table_alias ::= NK_ID */ yytestcase(yyruleno==312);
+      case 313: /* column_alias ::= NK_ID */ yytestcase(yyruleno==313);
+      case 314: /* user_name ::= NK_ID */ yytestcase(yyruleno==314);
+      case 315: /* index_name ::= NK_ID */ yytestcase(yyruleno==315);
+      case 316: /* topic_name ::= NK_ID */ yytestcase(yyruleno==316);
+      case 317: /* stream_name ::= NK_ID */ yytestcase(yyruleno==317);
+      case 318: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==318);
+      case 353: /* noarg_func ::= NOW */ yytestcase(yyruleno==353);
+      case 354: /* noarg_func ::= TODAY */ yytestcase(yyruleno==354);
+      case 355: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==355);
+      case 356: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==356);
+      case 357: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==357);
+      case 358: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==358);
+      case 359: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==359);
+      case 360: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==360);
+      case 361: /* noarg_func ::= USER */ yytestcase(yyruleno==361);
+      case 362: /* star_func ::= COUNT */ yytestcase(yyruleno==362);
+      case 363: /* star_func ::= FIRST */ yytestcase(yyruleno==363);
+      case 364: /* star_func ::= LAST */ yytestcase(yyruleno==364);
+      case 365: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==365);
 { yylhsminor.yy401 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy401 = yylhsminor.yy401;
         break;
@@ -3477,7 +3473,7 @@ static YYACTIONTYPE yy_reduce(
       case 70: /* exists_opt ::= */ yytestcase(yyruleno==70);
       case 249: /* analyze_opt ::= */ yytestcase(yyruleno==249);
       case 257: /* agg_func_opt ::= */ yytestcase(yyruleno==257);
-      case 418: /* set_quantifier_opt ::= */ yytestcase(yyruleno==418);
+      case 419: /* set_quantifier_opt ::= */ yytestcase(yyruleno==419);
 { yymsp[1].minor.yy89 = false; }
         break;
       case 69: /* exists_opt ::= IF EXISTS */
@@ -3617,10 +3613,10 @@ static YYACTIONTYPE yy_reduce(
       case 180: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==180);
       case 185: /* col_name_list ::= col_name */ yytestcase(yyruleno==185);
       case 232: /* func_list ::= func */ yytestcase(yyruleno==232);
-      case 305: /* literal_list ::= signed_literal */ yytestcase(yyruleno==305);
-      case 367: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==367);
-      case 421: /* select_list ::= select_item */ yytestcase(yyruleno==421);
-      case 475: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==475);
+      case 306: /* literal_list ::= signed_literal */ yytestcase(yyruleno==306);
+      case 368: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==368);
+      case 422: /* select_list ::= select_item */ yytestcase(yyruleno==422);
+      case 476: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==476);
 { yylhsminor.yy552 = createNodeList(pCxt, yymsp[0].minor.yy248); }
   yymsp[0].minor.yy552 = yylhsminor.yy552;
         break;
@@ -3629,10 +3625,10 @@ static YYACTIONTYPE yy_reduce(
       case 181: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==181);
       case 186: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==186);
       case 233: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==233);
-      case 306: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==306);
-      case 368: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==368);
-      case 422: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==422);
-      case 476: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==476);
+      case 307: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==307);
+      case 369: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==369);
+      case 423: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==423);
+      case 477: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==477);
 { yylhsminor.yy552 = addNodeToList(pCxt, yymsp[-2].minor.yy552, yymsp[0].minor.yy248); }
   yymsp[-2].minor.yy552 = yylhsminor.yy552;
         break;
@@ -3705,7 +3701,7 @@ static YYACTIONTYPE yy_reduce(
 { yylhsminor.yy552 = addNodeToList(pCxt, yymsp[-1].minor.yy552, yymsp[0].minor.yy248); }
   yymsp[-1].minor.yy552 = yylhsminor.yy552;
         break;
-      case 129: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP expression_list NK_RP table_options */
+      case 129: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */
 { yylhsminor.yy248 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy89, yymsp[-8].minor.yy248, yymsp[-6].minor.yy248, yymsp[-5].minor.yy552, yymsp[-2].minor.yy552, yymsp[0].minor.yy248); }
   yymsp[-9].minor.yy248 = yylhsminor.yy248;
         break;
@@ -3713,14 +3709,14 @@ static YYACTIONTYPE yy_reduce(
 { yylhsminor.yy248 = createDropTableClause(pCxt, yymsp[-1].minor.yy89, yymsp[0].minor.yy248); }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 133: /* specific_tags_opt ::= */
+      case 133: /* specific_cols_opt ::= */
       case 164: /* tags_def_opt ::= */ yytestcase(yyruleno==164);
-      case 430: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==430);
-      case 447: /* group_by_clause_opt ::= */ yytestcase(yyruleno==447);
-      case 463: /* order_by_clause_opt ::= */ yytestcase(yyruleno==463);
+      case 431: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==431);
+      case 448: /* group_by_clause_opt ::= */ yytestcase(yyruleno==448);
+      case 464: /* order_by_clause_opt ::= */ yytestcase(yyruleno==464);
 { yymsp[1].minor.yy552 = NULL; }
         break;
-      case 134: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */
+      case 134: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */
 { yymsp[-2].minor.yy552 = yymsp[-1].minor.yy552; }
         break;
       case 135: /* full_table_name ::= table_name */
@@ -3807,7 +3803,7 @@ static YYACTIONTYPE yy_reduce(
 { yymsp[-5].minor.yy224 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
         break;
       case 165: /* tags_def_opt ::= tags_def */
-      case 366: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==366);
+      case 367: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==367);
 { yylhsminor.yy552 = yymsp[0].minor.yy552; }
   yymsp[0].minor.yy552 = yylhsminor.yy552;
         break;
@@ -3856,12 +3852,12 @@ static YYACTIONTYPE yy_reduce(
 { yymsp[-1].minor.yy301.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy301.val = yymsp[0].minor.yy0; }
         break;
       case 178: /* duration_list ::= duration_literal */
-      case 334: /* expression_list ::= expression */ yytestcase(yyruleno==334);
+      case 335: /* expression_list ::= expression */ yytestcase(yyruleno==335);
 { yylhsminor.yy552 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy248)); }
   yymsp[0].minor.yy552 = yylhsminor.yy552;
         break;
       case 179: /* duration_list ::= duration_list NK_COMMA duration_literal */
-      case 335: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==335);
+      case 336: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==336);
 { yylhsminor.yy552 = addNodeToList(pCxt, yymsp[-2].minor.yy552, releaseRawExprNode(pCxt, yymsp[0].minor.yy248)); }
   yymsp[-2].minor.yy552 = yylhsminor.yy552;
         break;
@@ -3985,16 +3981,16 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 223: /* like_pattern_opt ::= */
       case 263: /* into_opt ::= */ yytestcase(yyruleno==263);
-      case 399: /* from_clause_opt ::= */ yytestcase(yyruleno==399);
-      case 428: /* where_clause_opt ::= */ yytestcase(yyruleno==428);
-      case 432: /* twindow_clause_opt ::= */ yytestcase(yyruleno==432);
-      case 437: /* sliding_opt ::= */ yytestcase(yyruleno==437);
-      case 439: /* fill_opt ::= */ yytestcase(yyruleno==439);
-      case 451: /* having_clause_opt ::= */ yytestcase(yyruleno==451);
-      case 453: /* range_opt ::= */ yytestcase(yyruleno==453);
-      case 455: /* every_opt ::= */ yytestcase(yyruleno==455);
-      case 465: /* slimit_clause_opt ::= */ yytestcase(yyruleno==465);
-      case 469: /* limit_clause_opt ::= */ yytestcase(yyruleno==469);
+      case 400: /* from_clause_opt ::= */ yytestcase(yyruleno==400);
+      case 429: /* where_clause_opt ::= */ yytestcase(yyruleno==429);
+      case 433: /* twindow_clause_opt ::= */ yytestcase(yyruleno==433);
+      case 438: /* sliding_opt ::= */ yytestcase(yyruleno==438);
+      case 440: /* fill_opt ::= */ yytestcase(yyruleno==440);
+      case 452: /* having_clause_opt ::= */ yytestcase(yyruleno==452);
+      case 454: /* range_opt ::= */ yytestcase(yyruleno==454);
+      case 456: /* every_opt ::= */ yytestcase(yyruleno==456);
+      case 466: /* slimit_clause_opt ::= */ yytestcase(yyruleno==466);
+      case 470: /* limit_clause_opt ::= */ yytestcase(yyruleno==470);
 { yymsp[1].minor.yy248 = NULL; }
         break;
       case 224: /* like_pattern_opt ::= LIKE NK_STRING */
@@ -4069,7 +4065,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 250: /* analyze_opt ::= ANALYZE */
       case 258: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==258);
-      case 419: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==419);
+      case 420: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==420);
 { yymsp[0].minor.yy89 = true; }
         break;
       case 251: /* explain_options ::= */
@@ -4105,9 +4101,9 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy89, &yymsp[0].minor.yy401); }
         break;
       case 264: /* into_opt ::= INTO full_table_name */
-      case 400: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==400);
-      case 429: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==429);
-      case 452: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==452);
+      case 401: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==401);
+      case 430: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==430);
+      case 453: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==453);
 { yymsp[-1].minor.yy248 = yymsp[0].minor.yy248; }
         break;
       case 266: /* stream_options ::= stream_options TRIGGER AT_ONCE */
@@ -4156,67 +4152,70 @@ static YYACTIONTYPE yy_reduce(
       case 281: /* cmd ::= DELETE FROM full_table_name where_clause_opt */
 { pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy248, yymsp[0].minor.yy248); }
         break;
-      case 283: /* literal ::= NK_INTEGER */
+      case 283: /* cmd ::= INSERT INTO full_table_name specific_cols_opt query_expression */
+{ pCxt->pRootNode = createInsertStmt(pCxt, yymsp[-2].minor.yy248, yymsp[-1].minor.yy552, yymsp[0].minor.yy248); }
+        break;
+      case 284: /* literal ::= NK_INTEGER */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 284: /* literal ::= NK_FLOAT */
+      case 285: /* literal ::= NK_FLOAT */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 285: /* literal ::= NK_STRING */
+      case 286: /* literal ::= NK_STRING */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 286: /* literal ::= NK_BOOL */
+      case 287: /* literal ::= NK_BOOL */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 287: /* literal ::= TIMESTAMP NK_STRING */
+      case 288: /* literal ::= TIMESTAMP NK_STRING */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 288: /* literal ::= duration_literal */
-      case 298: /* signed_literal ::= signed */ yytestcase(yyruleno==298);
-      case 318: /* expression ::= literal */ yytestcase(yyruleno==318);
-      case 319: /* expression ::= pseudo_column */ yytestcase(yyruleno==319);
-      case 320: /* expression ::= column_reference */ yytestcase(yyruleno==320);
-      case 321: /* expression ::= function_expression */ yytestcase(yyruleno==321);
-      case 322: /* expression ::= subquery */ yytestcase(yyruleno==322);
-      case 349: /* function_expression ::= literal_func */ yytestcase(yyruleno==349);
-      case 391: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==391);
-      case 395: /* boolean_primary ::= predicate */ yytestcase(yyruleno==395);
-      case 397: /* common_expression ::= expression */ yytestcase(yyruleno==397);
-      case 398: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==398);
-      case 401: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==401);
-      case 403: /* table_reference ::= table_primary */ yytestcase(yyruleno==403);
-      case 404: /* table_reference ::= joined_table */ yytestcase(yyruleno==404);
-      case 408: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==408);
-      case 458: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==458);
-      case 461: /* query_primary ::= query_specification */ yytestcase(yyruleno==461);
+      case 289: /* literal ::= duration_literal */
+      case 299: /* signed_literal ::= signed */ yytestcase(yyruleno==299);
+      case 319: /* expression ::= literal */ yytestcase(yyruleno==319);
+      case 320: /* expression ::= pseudo_column */ yytestcase(yyruleno==320);
+      case 321: /* expression ::= column_reference */ yytestcase(yyruleno==321);
+      case 322: /* expression ::= function_expression */ yytestcase(yyruleno==322);
+      case 323: /* expression ::= subquery */ yytestcase(yyruleno==323);
+      case 350: /* function_expression ::= literal_func */ yytestcase(yyruleno==350);
+      case 392: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==392);
+      case 396: /* boolean_primary ::= predicate */ yytestcase(yyruleno==396);
+      case 398: /* common_expression ::= expression */ yytestcase(yyruleno==398);
+      case 399: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==399);
+      case 402: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==402);
+      case 404: /* table_reference ::= table_primary */ yytestcase(yyruleno==404);
+      case 405: /* table_reference ::= joined_table */ yytestcase(yyruleno==405);
+      case 409: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==409);
+      case 459: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==459);
+      case 462: /* query_primary ::= query_specification */ yytestcase(yyruleno==462);
 { yylhsminor.yy248 = yymsp[0].minor.yy248; }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 289: /* literal ::= NULL */
+      case 290: /* literal ::= NULL */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 290: /* literal ::= NK_QUESTION */
+      case 291: /* literal ::= NK_QUESTION */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 291: /* duration_literal ::= NK_VARIABLE */
+      case 292: /* duration_literal ::= NK_VARIABLE */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 292: /* signed ::= NK_INTEGER */
+      case 293: /* signed ::= NK_INTEGER */
 { yylhsminor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 293: /* signed ::= NK_PLUS NK_INTEGER */
+      case 294: /* signed ::= NK_PLUS NK_INTEGER */
 { yymsp[-1].minor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
-      case 294: /* signed ::= NK_MINUS NK_INTEGER */
+      case 295: /* signed ::= NK_MINUS NK_INTEGER */
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
@@ -4224,14 +4223,14 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 295: /* signed ::= NK_FLOAT */
+      case 296: /* signed ::= NK_FLOAT */
 { yylhsminor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 296: /* signed ::= NK_PLUS NK_FLOAT */
+      case 297: /* signed ::= NK_PLUS NK_FLOAT */
 { yymsp[-1].minor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
         break;
-      case 297: /* signed ::= NK_MINUS NK_FLOAT */
+      case 298: /* signed ::= NK_MINUS NK_FLOAT */
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
@@ -4239,49 +4238,49 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 299: /* signed_literal ::= NK_STRING */
+      case 300: /* signed_literal ::= NK_STRING */
 { yylhsminor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 300: /* signed_literal ::= NK_BOOL */
+      case 301: /* signed_literal ::= NK_BOOL */
 { yylhsminor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 301: /* signed_literal ::= TIMESTAMP NK_STRING */
+      case 302: /* signed_literal ::= TIMESTAMP NK_STRING */
 { yymsp[-1].minor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
         break;
-      case 302: /* signed_literal ::= duration_literal */
-      case 304: /* signed_literal ::= literal_func */ yytestcase(yyruleno==304);
-      case 369: /* star_func_para ::= expression */ yytestcase(yyruleno==369);
-      case 424: /* select_item ::= common_expression */ yytestcase(yyruleno==424);
-      case 474: /* search_condition ::= common_expression */ yytestcase(yyruleno==474);
+      case 303: /* signed_literal ::= duration_literal */
+      case 305: /* signed_literal ::= literal_func */ yytestcase(yyruleno==305);
+      case 370: /* star_func_para ::= expression */ yytestcase(yyruleno==370);
+      case 425: /* select_item ::= common_expression */ yytestcase(yyruleno==425);
+      case 475: /* search_condition ::= common_expression */ yytestcase(yyruleno==475);
 { yylhsminor.yy248 = releaseRawExprNode(pCxt, yymsp[0].minor.yy248); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 303: /* signed_literal ::= NULL */
+      case 304: /* signed_literal ::= NULL */
 { yylhsminor.yy248 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 323: /* expression ::= NK_LP expression NK_RP */
-      case 396: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==396);
+      case 324: /* expression ::= NK_LP expression NK_RP */
+      case 397: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==397);
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy248)); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 324: /* expression ::= NK_PLUS expression */
+      case 325: /* expression ::= NK_PLUS expression */
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy248));
                                                                                   }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 325: /* expression ::= NK_MINUS expression */
+      case 326: /* expression ::= NK_MINUS expression */
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy248), NULL));
                                                                                   }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 326: /* expression ::= expression NK_PLUS expression */
+      case 327: /* expression ::= expression NK_PLUS expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4289,7 +4288,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 327: /* expression ::= expression NK_MINUS expression */
+      case 328: /* expression ::= expression NK_MINUS expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4297,7 +4296,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 328: /* expression ::= expression NK_STAR expression */
+      case 329: /* expression ::= expression NK_STAR expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4305,7 +4304,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 329: /* expression ::= expression NK_SLASH expression */
+      case 330: /* expression ::= expression NK_SLASH expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4313,7 +4312,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 330: /* expression ::= expression NK_REM expression */
+      case 331: /* expression ::= expression NK_REM expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4321,14 +4320,14 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 331: /* expression ::= column_reference NK_ARROW NK_STRING */
+      case 332: /* expression ::= column_reference NK_ARROW NK_STRING */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy248), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); 
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 332: /* expression ::= expression NK_BITAND expression */
+      case 333: /* expression ::= expression NK_BITAND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4336,7 +4335,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 333: /* expression ::= expression NK_BITOR expression */
+      case 334: /* expression ::= expression NK_BITOR expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4344,53 +4343,53 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 336: /* column_reference ::= column_name */
+      case 337: /* column_reference ::= column_name */
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy401, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy401)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 337: /* column_reference ::= table_name NK_DOT column_name */
+      case 338: /* column_reference ::= table_name NK_DOT column_name */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy401, &yymsp[0].minor.yy401, createColumnNode(pCxt, &yymsp[-2].minor.yy401, &yymsp[0].minor.yy401)); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 338: /* pseudo_column ::= ROWTS */
-      case 339: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==339);
-      case 341: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==341);
-      case 342: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==342);
-      case 343: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==343);
-      case 344: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==344);
-      case 345: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==345);
-      case 351: /* literal_func ::= NOW */ yytestcase(yyruleno==351);
+      case 339: /* pseudo_column ::= ROWTS */
+      case 340: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==340);
+      case 342: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==342);
+      case 343: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==343);
+      case 344: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==344);
+      case 345: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==345);
+      case 346: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==346);
+      case 352: /* literal_func ::= NOW */ yytestcase(yyruleno==352);
 { yylhsminor.yy248 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 340: /* pseudo_column ::= table_name NK_DOT TBNAME */
+      case 341: /* pseudo_column ::= table_name NK_DOT TBNAME */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy401, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy401)))); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 346: /* function_expression ::= function_name NK_LP expression_list NK_RP */
-      case 347: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==347);
+      case 347: /* function_expression ::= function_name NK_LP expression_list NK_RP */
+      case 348: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==348);
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy401, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy401, yymsp[-1].minor.yy552)); }
   yymsp[-3].minor.yy248 = yylhsminor.yy248;
         break;
-      case 348: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+      case 349: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), yymsp[-1].minor.yy224)); }
   yymsp[-5].minor.yy248 = yylhsminor.yy248;
         break;
-      case 350: /* literal_func ::= noarg_func NK_LP NK_RP */
+      case 351: /* literal_func ::= noarg_func NK_LP NK_RP */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy401, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy401, NULL)); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 365: /* star_func_para_list ::= NK_STAR */
+      case 366: /* star_func_para_list ::= NK_STAR */
 { yylhsminor.yy552 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy552 = yylhsminor.yy552;
         break;
-      case 370: /* star_func_para ::= table_name NK_DOT NK_STAR */
-      case 427: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==427);
+      case 371: /* star_func_para ::= table_name NK_DOT NK_STAR */
+      case 428: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==428);
 { yylhsminor.yy248 = createColumnNode(pCxt, &yymsp[-2].minor.yy401, &yymsp[0].minor.yy0); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 371: /* predicate ::= expression compare_op expression */
-      case 376: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==376);
+      case 372: /* predicate ::= expression compare_op expression */
+      case 377: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==377);
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4398,7 +4397,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 372: /* predicate ::= expression BETWEEN expression AND expression */
+      case 373: /* predicate ::= expression BETWEEN expression AND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4406,7 +4405,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-4].minor.yy248 = yylhsminor.yy248;
         break;
-      case 373: /* predicate ::= expression NOT BETWEEN expression AND expression */
+      case 374: /* predicate ::= expression NOT BETWEEN expression AND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4414,71 +4413,71 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-5].minor.yy248 = yylhsminor.yy248;
         break;
-      case 374: /* predicate ::= expression IS NULL */
+      case 375: /* predicate ::= expression IS NULL */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy248), NULL));
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 375: /* predicate ::= expression IS NOT NULL */
+      case 376: /* predicate ::= expression IS NOT NULL */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), NULL));
                                                                                   }
   yymsp[-3].minor.yy248 = yylhsminor.yy248;
         break;
-      case 377: /* compare_op ::= NK_LT */
+      case 378: /* compare_op ::= NK_LT */
 { yymsp[0].minor.yy716 = OP_TYPE_LOWER_THAN; }
         break;
-      case 378: /* compare_op ::= NK_GT */
+      case 379: /* compare_op ::= NK_GT */
 { yymsp[0].minor.yy716 = OP_TYPE_GREATER_THAN; }
         break;
-      case 379: /* compare_op ::= NK_LE */
+      case 380: /* compare_op ::= NK_LE */
 { yymsp[0].minor.yy716 = OP_TYPE_LOWER_EQUAL; }
         break;
-      case 380: /* compare_op ::= NK_GE */
+      case 381: /* compare_op ::= NK_GE */
 { yymsp[0].minor.yy716 = OP_TYPE_GREATER_EQUAL; }
         break;
-      case 381: /* compare_op ::= NK_NE */
+      case 382: /* compare_op ::= NK_NE */
 { yymsp[0].minor.yy716 = OP_TYPE_NOT_EQUAL; }
         break;
-      case 382: /* compare_op ::= NK_EQ */
+      case 383: /* compare_op ::= NK_EQ */
 { yymsp[0].minor.yy716 = OP_TYPE_EQUAL; }
         break;
-      case 383: /* compare_op ::= LIKE */
+      case 384: /* compare_op ::= LIKE */
 { yymsp[0].minor.yy716 = OP_TYPE_LIKE; }
         break;
-      case 384: /* compare_op ::= NOT LIKE */
+      case 385: /* compare_op ::= NOT LIKE */
 { yymsp[-1].minor.yy716 = OP_TYPE_NOT_LIKE; }
         break;
-      case 385: /* compare_op ::= MATCH */
+      case 386: /* compare_op ::= MATCH */
 { yymsp[0].minor.yy716 = OP_TYPE_MATCH; }
         break;
-      case 386: /* compare_op ::= NMATCH */
+      case 387: /* compare_op ::= NMATCH */
 { yymsp[0].minor.yy716 = OP_TYPE_NMATCH; }
         break;
-      case 387: /* compare_op ::= CONTAINS */
+      case 388: /* compare_op ::= CONTAINS */
 { yymsp[0].minor.yy716 = OP_TYPE_JSON_CONTAINS; }
         break;
-      case 388: /* in_op ::= IN */
+      case 389: /* in_op ::= IN */
 { yymsp[0].minor.yy716 = OP_TYPE_IN; }
         break;
-      case 389: /* in_op ::= NOT IN */
+      case 390: /* in_op ::= NOT IN */
 { yymsp[-1].minor.yy716 = OP_TYPE_NOT_IN; }
         break;
-      case 390: /* in_predicate_value ::= NK_LP expression_list NK_RP */
+      case 391: /* in_predicate_value ::= NK_LP expression_list NK_RP */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy552)); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 392: /* boolean_value_expression ::= NOT boolean_primary */
+      case 393: /* boolean_value_expression ::= NOT boolean_primary */
 {
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
                                                                                     yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy248), NULL));
                                                                                   }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 393: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+      case 394: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4486,7 +4485,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 394: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+      case 395: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy248);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy248);
@@ -4494,47 +4493,47 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 402: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
+      case 403: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
 { yylhsminor.yy248 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy248, yymsp[0].minor.yy248, NULL); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 405: /* table_primary ::= table_name alias_opt */
+      case 406: /* table_primary ::= table_name alias_opt */
 { yylhsminor.yy248 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy401, &yymsp[0].minor.yy401); }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 406: /* table_primary ::= db_name NK_DOT table_name alias_opt */
+      case 407: /* table_primary ::= db_name NK_DOT table_name alias_opt */
 { yylhsminor.yy248 = createRealTableNode(pCxt, &yymsp[-3].minor.yy401, &yymsp[-1].minor.yy401, &yymsp[0].minor.yy401); }
   yymsp[-3].minor.yy248 = yylhsminor.yy248;
         break;
-      case 407: /* table_primary ::= subquery alias_opt */
+      case 408: /* table_primary ::= subquery alias_opt */
 { yylhsminor.yy248 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy248), &yymsp[0].minor.yy401); }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 409: /* alias_opt ::= */
+      case 410: /* alias_opt ::= */
 { yymsp[1].minor.yy401 = nil_token;  }
         break;
-      case 410: /* alias_opt ::= table_alias */
+      case 411: /* alias_opt ::= table_alias */
 { yylhsminor.yy401 = yymsp[0].minor.yy401; }
   yymsp[0].minor.yy401 = yylhsminor.yy401;
         break;
-      case 411: /* alias_opt ::= AS table_alias */
+      case 412: /* alias_opt ::= AS table_alias */
 { yymsp[-1].minor.yy401 = yymsp[0].minor.yy401; }
         break;
-      case 412: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-      case 413: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==413);
+      case 413: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+      case 414: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==414);
 { yymsp[-2].minor.yy248 = yymsp[-1].minor.yy248; }
         break;
-      case 414: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+      case 415: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
 { yylhsminor.yy248 = createJoinTableNode(pCxt, yymsp[-4].minor.yy52, yymsp[-5].minor.yy248, yymsp[-2].minor.yy248, yymsp[0].minor.yy248); }
   yymsp[-5].minor.yy248 = yylhsminor.yy248;
         break;
-      case 415: /* join_type ::= */
+      case 416: /* join_type ::= */
 { yymsp[1].minor.yy52 = JOIN_TYPE_INNER; }
         break;
-      case 416: /* join_type ::= INNER */
+      case 417: /* join_type ::= INNER */
 { yymsp[0].minor.yy52 = JOIN_TYPE_INNER; }
         break;
-      case 417: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+      case 418: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
 { 
                                                                                     yymsp[-11].minor.yy248 = createSelectStmt(pCxt, yymsp[-10].minor.yy89, yymsp[-9].minor.yy552, yymsp[-8].minor.yy248);
                                                                                     yymsp[-11].minor.yy248 = addWhereClause(pCxt, yymsp[-11].minor.yy248, yymsp[-7].minor.yy248);
@@ -4547,75 +4546,75 @@ static YYACTIONTYPE yy_reduce(
                                                                                     yymsp[-11].minor.yy248 = addFillClause(pCxt, yymsp[-11].minor.yy248, yymsp[-3].minor.yy248);
                                                                                   }
         break;
-      case 420: /* set_quantifier_opt ::= ALL */
+      case 421: /* set_quantifier_opt ::= ALL */
 { yymsp[0].minor.yy89 = false; }
         break;
-      case 423: /* select_item ::= NK_STAR */
+      case 424: /* select_item ::= NK_STAR */
 { yylhsminor.yy248 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy248 = yylhsminor.yy248;
         break;
-      case 425: /* select_item ::= common_expression column_alias */
+      case 426: /* select_item ::= common_expression column_alias */
 { yylhsminor.yy248 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy248), &yymsp[0].minor.yy401); }
   yymsp[-1].minor.yy248 = yylhsminor.yy248;
         break;
-      case 426: /* select_item ::= common_expression AS column_alias */
+      case 427: /* select_item ::= common_expression AS column_alias */
 { yylhsminor.yy248 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy248), &yymsp[0].minor.yy401); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 431: /* partition_by_clause_opt ::= PARTITION BY expression_list */
-      case 448: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==448);
-      case 464: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==464);
+      case 432: /* partition_by_clause_opt ::= PARTITION BY expression_list */
+      case 449: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==449);
+      case 465: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==465);
 { yymsp[-2].minor.yy552 = yymsp[0].minor.yy552; }
         break;
-      case 433: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+      case 434: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
 { yymsp[-5].minor.yy248 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), releaseRawExprNode(pCxt, yymsp[-1].minor.yy248)); }
         break;
-      case 434: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+      case 435: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
 { yymsp[-3].minor.yy248 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy248)); }
         break;
-      case 435: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+      case 436: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
 { yymsp[-5].minor.yy248 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), NULL, yymsp[-1].minor.yy248, yymsp[0].minor.yy248); }
         break;
-      case 436: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+      case 437: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
 { yymsp[-7].minor.yy248 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy248), releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), yymsp[-1].minor.yy248, yymsp[0].minor.yy248); }
         break;
-      case 438: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-      case 456: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==456);
+      case 439: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+      case 457: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==457);
 { yymsp[-3].minor.yy248 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy248); }
         break;
-      case 440: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
+      case 441: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
 { yymsp[-3].minor.yy248 = createFillNode(pCxt, yymsp[-1].minor.yy582, NULL); }
         break;
-      case 441: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+      case 442: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
 { yymsp[-5].minor.yy248 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy552)); }
         break;
-      case 442: /* fill_mode ::= NONE */
+      case 443: /* fill_mode ::= NONE */
 { yymsp[0].minor.yy582 = FILL_MODE_NONE; }
         break;
-      case 443: /* fill_mode ::= PREV */
+      case 444: /* fill_mode ::= PREV */
 { yymsp[0].minor.yy582 = FILL_MODE_PREV; }
         break;
-      case 444: /* fill_mode ::= NULL */
+      case 445: /* fill_mode ::= NULL */
 { yymsp[0].minor.yy582 = FILL_MODE_NULL; }
         break;
-      case 445: /* fill_mode ::= LINEAR */
+      case 446: /* fill_mode ::= LINEAR */
 { yymsp[0].minor.yy582 = FILL_MODE_LINEAR; }
         break;
-      case 446: /* fill_mode ::= NEXT */
+      case 447: /* fill_mode ::= NEXT */
 { yymsp[0].minor.yy582 = FILL_MODE_NEXT; }
         break;
-      case 449: /* group_by_list ::= expression */
+      case 450: /* group_by_list ::= expression */
 { yylhsminor.yy552 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy248))); }
   yymsp[0].minor.yy552 = yylhsminor.yy552;
         break;
-      case 450: /* group_by_list ::= group_by_list NK_COMMA expression */
+      case 451: /* group_by_list ::= group_by_list NK_COMMA expression */
 { yylhsminor.yy552 = addNodeToList(pCxt, yymsp[-2].minor.yy552, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy248))); }
   yymsp[-2].minor.yy552 = yylhsminor.yy552;
         break;
-      case 454: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+      case 455: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
 { yymsp[-5].minor.yy248 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy248), releaseRawExprNode(pCxt, yymsp[-1].minor.yy248)); }
         break;
-      case 457: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+      case 458: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
 { 
                                                                                     yylhsminor.yy248 = addOrderByClause(pCxt, yymsp[-3].minor.yy248, yymsp[-2].minor.yy552);
                                                                                     yylhsminor.yy248 = addSlimitClause(pCxt, yylhsminor.yy248, yymsp[-1].minor.yy248);
@@ -4623,56 +4622,56 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-3].minor.yy248 = yylhsminor.yy248;
         break;
-      case 459: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+      case 460: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
 { yylhsminor.yy248 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy248, yymsp[0].minor.yy248); }
   yymsp[-3].minor.yy248 = yylhsminor.yy248;
         break;
-      case 460: /* query_expression_body ::= query_expression_body UNION query_expression_body */
+      case 461: /* query_expression_body ::= query_expression_body UNION query_expression_body */
 { yylhsminor.yy248 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy248, yymsp[0].minor.yy248); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 462: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+      case 463: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
 { yymsp[-5].minor.yy248 = yymsp[-4].minor.yy248; }
   yy_destructor(yypParser,368,&yymsp[-3].minor);
   yy_destructor(yypParser,369,&yymsp[-2].minor);
   yy_destructor(yypParser,370,&yymsp[-1].minor);
         break;
-      case 466: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
-      case 470: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==470);
+      case 467: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+      case 471: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==471);
 { yymsp[-1].minor.yy248 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
         break;
-      case 467: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-      case 471: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==471);
+      case 468: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 472: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==472);
 { yymsp[-3].minor.yy248 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
         break;
-      case 468: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-      case 472: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==472);
+      case 469: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 473: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==473);
 { yymsp[-3].minor.yy248 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
         break;
-      case 473: /* subquery ::= NK_LP query_expression NK_RP */
+      case 474: /* subquery ::= NK_LP query_expression NK_RP */
 { yylhsminor.yy248 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy248); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 477: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+      case 478: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
 { yylhsminor.yy248 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy248), yymsp[-1].minor.yy482, yymsp[0].minor.yy345); }
   yymsp[-2].minor.yy248 = yylhsminor.yy248;
         break;
-      case 478: /* ordering_specification_opt ::= */
+      case 479: /* ordering_specification_opt ::= */
 { yymsp[1].minor.yy482 = ORDER_ASC; }
         break;
-      case 479: /* ordering_specification_opt ::= ASC */
+      case 480: /* ordering_specification_opt ::= ASC */
 { yymsp[0].minor.yy482 = ORDER_ASC; }
         break;
-      case 480: /* ordering_specification_opt ::= DESC */
+      case 481: /* ordering_specification_opt ::= DESC */
 { yymsp[0].minor.yy482 = ORDER_DESC; }
         break;
-      case 481: /* null_ordering_opt ::= */
+      case 482: /* null_ordering_opt ::= */
 { yymsp[1].minor.yy345 = NULL_ORDER_DEFAULT; }
         break;
-      case 482: /* null_ordering_opt ::= NULLS FIRST */
+      case 483: /* null_ordering_opt ::= NULLS FIRST */
 { yymsp[-1].minor.yy345 = NULL_ORDER_FIRST; }
         break;
-      case 483: /* null_ordering_opt ::= NULLS LAST */
+      case 484: /* null_ordering_opt ::= NULLS LAST */
 { yymsp[-1].minor.yy345 = NULL_ORDER_LAST; }
         break;
       default:
diff --git a/source/libs/parser/test/parExplainToSyncdbTest.cpp b/source/libs/parser/test/parExplainToSyncdbTest.cpp
index 4a5a92e621..72083c68ca 100644
--- a/source/libs/parser/test/parExplainToSyncdbTest.cpp
+++ b/source/libs/parser/test/parExplainToSyncdbTest.cpp
@@ -40,6 +40,12 @@ TEST_F(ParserExplainToSyncdbTest, grant) {
   run("GRANT READ, WRITE ON test.* TO wxy");
 }
 
+TEST_F(ParserExplainToSyncdbTest, insert) {
+  useDb("root", "test");
+
+  run("INSERT INTO t1 SELECT * FROM t1");
+}
+
 // todo kill connection
 // todo kill query
 // todo kill stream
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index bdf2965fe5..2eef2b5381 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -26,6 +26,7 @@ typedef int32_t (*FCreateLogicNode)(SLogicPlanContext*, void*, SLogicNode**);
 typedef int32_t (*FCreateSelectLogicNode)(SLogicPlanContext*, SSelectStmt*, SLogicNode**);
 typedef int32_t (*FCreateSetOpLogicNode)(SLogicPlanContext*, SSetOperator*, SLogicNode**);
 typedef int32_t (*FCreateDeleteLogicNode)(SLogicPlanContext*, SDeleteStmt*, SLogicNode**);
+typedef int32_t (*FCreateInsertLogicNode)(SLogicPlanContext*, SInsertStmt*, SLogicNode**);
 
 static int32_t doCreateLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SNode* pTable,
                                         SLogicNode** pLogicNode);
@@ -1264,6 +1265,47 @@ static int32_t createDeleteLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDele
   return code;
 }
 
+static int32_t creatInsertRootLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pInsert, FCreateInsertLogicNode func,
+                                        SLogicNode** pRoot) {
+  return createRootLogicNode(pCxt, pInsert, pInsert->precision, (FCreateLogicNode)func, pRoot);
+}
+
+static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert,
+                                                 SLogicNode** pLogicNode) {
+  SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY);
+  if (NULL == pModify) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  SRealTableNode* pRealTable = (SRealTableNode*)pInsert->pTable;
+
+  pModify->modifyType = MODIFY_TABLE_TYPE_INSERT;
+  pModify->tableId = pRealTable->pMeta->uid;
+  pModify->tableType = pRealTable->pMeta->tableType;
+  snprintf(pModify->tableFName, sizeof(pModify->tableFName), "%d.%s.%s", pCxt->pPlanCxt->acctId,
+           pRealTable->table.dbName, pRealTable->table.tableName);
+  TSWAP(pModify->pVgroupList, pRealTable->pVgroupList);
+
+  *pLogicNode = (SLogicNode*)pModify;
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t createInsertLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pInsert, SLogicNode** pLogicNode) {
+  SLogicNode* pRoot = NULL;
+  int32_t     code = createQueryLogicNode(pCxt, pInsert->pQuery, &pRoot);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = creatInsertRootLogicNode(pCxt, pInsert, createVnodeModifLogicNodeByInsert, &pRoot);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = pRoot;
+  } else {
+    nodesDestroyNode((SNode*)pRoot);
+  }
+
+  return code;
+}
+
 static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogicNode** pLogicNode) {
   switch (nodeType(pStmt)) {
     case QUERY_NODE_SELECT_STMT:
@@ -1276,6 +1318,8 @@ static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogi
       return createSetOperatorLogicNode(pCxt, (SSetOperator*)pStmt, pLogicNode);
     case QUERY_NODE_DELETE_STMT:
       return createDeleteLogicNode(pCxt, (SDeleteStmt*)pStmt, pLogicNode);
+    case QUERY_NODE_INSERT_STMT:
+      return createInsertLogicNode(pCxt, (SInsertStmt*)pStmt, pLogicNode);
     default:
       break;
   }
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index 202e590955..ea8bae8259 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -485,7 +485,7 @@ static int32_t pushDownCondOptPushCondToProject(SOptimizeContext* pCxt, SProject
   return pushDownCondOptAppendCond(&pProject->node.pConditions, pCond);
 }
 
-static int32_t pushDownCondOptPushCondToJoin(SOptimizeContext* pCxt, SJoinLogicNode * pJoin, SNode** pCond) {
+static int32_t pushDownCondOptPushCondToJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin, SNode** pCond) {
   return pushDownCondOptAppendCond(&pJoin->node.pConditions, pCond);
 }
 
@@ -557,9 +557,9 @@ static int32_t pushDownCondOptCheckJoinOnCond(SOptimizeContext* pCxt, SJoinLogic
 static int32_t pushDownCondOptPartJoinOnCondLogicCond(SJoinLogicNode* pJoin, SNode** ppMergeCond, SNode** ppOnCond) {
   SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pJoin->pOnConditions);
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t    code = TSDB_CODE_SUCCESS;
   SNodeList* pOnConds = NULL;
-  SNode* pCond = NULL;
+  SNode*     pCond = NULL;
   FOREACH(pCond, pLogicCond->pParameterList) {
     if (pushDownCondOptIsPriKeyEqualCond(pJoin, pCond)) {
       *ppMergeCond = nodesCloneNode(pCond);
@@ -604,8 +604,8 @@ static int32_t pushDownCondOptPartJoinOnCond(SJoinLogicNode* pJoin, SNode** ppMe
 
 static int32_t pushDownCondOptJoinExtractMergeCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
   int32_t code = pushDownCondOptCheckJoinOnCond(pCxt, pJoin);
-  SNode* pJoinMergeCond = NULL;
-  SNode* pJoinOnCond = NULL;
+  SNode*  pJoinMergeCond = NULL;
+  SNode*  pJoinOnCond = NULL;
   if (TSDB_CODE_SUCCESS == code) {
     code = pushDownCondOptPartJoinOnCond(pJoin, &pJoinMergeCond, &pJoinOnCond);
   }
@@ -820,12 +820,12 @@ static int32_t pushDownCondOptDealAgg(SOptimizeContext* pCxt, SAggLogicNode* pAg
 
 typedef struct SRewriteProjCondContext {
   SProjectLogicNode* pProj;
-  int32_t errCode;
-}SRewriteProjCondContext;
+  int32_t            errCode;
+} SRewriteProjCondContext;
 
 static EDealRes rewriteProjectCondForPushDownImpl(SNode** ppNode, void* pContext) {
   SRewriteProjCondContext* pCxt = pContext;
-  SProjectLogicNode* pProj = pCxt->pProj;
+  SProjectLogicNode*       pProj = pCxt->pProj;
   if (QUERY_NODE_COLUMN == nodeType(*ppNode)) {
     SNode* pTarget = NULL;
     FOREACH(pTarget, pProj->node.pTargets) {
@@ -840,18 +840,19 @@ static EDealRes rewriteProjectCondForPushDownImpl(SNode** ppNode, void* pContext
             }
             nodesDestroyNode(*ppNode);
             *ppNode = pExpr;
-          } // end if expr alias name equal column name
-        } // end for each project
-      } // end if target node equals cond column node
-    } // end for each targets
+          }  // end if expr alias name equal column name
+        }    // end for each project
+      }      // end if target node equals cond column node
+    }        // end for each targets
     return DEAL_RES_IGNORE_CHILD;
   }
   return DEAL_RES_CONTINUE;
 }
 
-static int32_t rewriteProjectCondForPushDown(SOptimizeContext* pCxt, SProjectLogicNode* pProject, SNode** ppProjectCond) {
+static int32_t rewriteProjectCondForPushDown(SOptimizeContext* pCxt, SProjectLogicNode* pProject,
+                                             SNode** ppProjectCond) {
   SRewriteProjCondContext cxt = {.pProj = pProject, .errCode = TSDB_CODE_SUCCESS};
-  SNode* pProjectCond = pProject->node.pConditions;
+  SNode*                  pProjectCond = pProject->node.pConditions;
   nodesRewriteExpr(&pProjectCond, rewriteProjectCondForPushDownImpl, &cxt);
   *ppProjectCond = pProjectCond;
   pProject->node.pConditions = NULL;
@@ -873,7 +874,7 @@ static int32_t pushDownCondOptDealProject(SOptimizeContext* pCxt, SProjectLogicN
   }
 
   int32_t code = TSDB_CODE_SUCCESS;
-  SNode* pProjCond = NULL;
+  SNode*  pProjCond = NULL;
   code = rewriteProjectCondForPushDown(pCxt, pProject, &pProjCond);
   if (TSDB_CODE_SUCCESS == code) {
     SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pProject->node.pChildren, 0);
@@ -2082,13 +2083,18 @@ static const int32_t optimizeRuleNum = (sizeof(optimizeRuleSet) / sizeof(SOptimi
 static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
   char* pStr = NULL;
   nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
-  qDebugL("apply optimize %s rule: %s", pRuleName, pStr);
+  if (NULL == pRuleName) {
+    qDebugL("before optimize: %s", pStr);
+  } else {
+    qDebugL("apply optimize %s rule: %s", pRuleName, pStr);
+  }
   taosMemoryFree(pStr);
 }
 
 static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) {
   SOptimizeContext cxt = {.pPlanCxt = pCxt, .optimized = false};
   bool             optimized = false;
+  dumpLogicSubplan(NULL, pLogicSubplan);
   do {
     optimized = false;
     for (int32_t i = 0; i < optimizeRuleNum; ++i) {
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index d10908c519..7ec3af31b2 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -632,8 +632,8 @@ static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren
   }
 
   if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pOnConditions) {
-    code = setNodeSlotId(pCxt, ((SPhysiNode*)pJoin)->pOutputDataBlockDesc->dataBlockId, -1, pJoinLogicNode->pOnConditions,
-                         &pJoin->pOnConditions);
+    code = setNodeSlotId(pCxt, ((SPhysiNode*)pJoin)->pOutputDataBlockDesc->dataBlockId, -1,
+                         pJoinLogicNode->pOnConditions, &pJoin->pOnConditions);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -1496,12 +1496,60 @@ static SSubplan* makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubpl
   return pSubplan;
 }
 
-static int32_t buildInsertSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan) {
+static int32_t buildInsertValuesSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan) {
   pSubplan->msgType = pModify->msgType;
   pSubplan->execNode.epSet = pModify->pVgDataBlocks->vg.epSet;
   return createDataInserter(pCxt, pModify->pVgDataBlocks, &pSubplan->pDataSink);
 }
 
+static int32_t createQueryInserter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan,
+                                   SDataSinkNode** pSink) {
+  SQueryInserterNode* pInserter = (SQueryInserterNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT);
+  if (NULL == pInserter) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pInserter->tableId = pModify->tableId;
+  pInserter->tableType = pModify->tableType;
+  strcpy(pInserter->tableFName, pModify->tableFName);
+  pInserter->vgId = pModify->pVgroupList->vgroups[0].vgId;
+  pInserter->epSet = pModify->pVgroupList->vgroups[0].epSet;
+  vgroupInfoToNodeAddr(pModify->pVgroupList->vgroups, &pSubplan->execNode);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  pInserter->sink.pInputDataBlockDesc =
+      (SDataBlockDescNode*)nodesCloneNode((SNode*)pSubplan->pNode->pOutputDataBlockDesc);
+  if (NULL == pInserter->sink.pInputDataBlockDesc) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pSink = (SDataSinkNode*)pInserter;
+  } else {
+    nodesDestroyNode((SNode*)pInserter);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t buildInsertSelectSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan) {
+  int32_t code =
+      createPhysiNode(pCxt, (SLogicNode*)nodesListGetNode(pModify->node.pChildren, 0), pSubplan, &pSubplan->pNode);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createQueryInserter(pCxt, pModify, pSubplan, &pSubplan->pDataSink);
+  }
+  pSubplan->msgType = TDMT_VND_SUBMIT;
+  return code;
+}
+
+static int32_t buildInsertSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan) {
+  if (NULL == pModify->node.pChildren) {
+    return buildInsertValuesSubplan(pCxt, pModify, pSubplan);
+  }
+  return buildInsertSelectSubplan(pCxt, pModify, pSubplan);
+}
+
 static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, const SPhysiNode* pRoot,
                                  SDataSinkNode** pSink) {
   SDataDeleterNode* pDeleter = (SDataDeleterNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_DELETE);
diff --git a/source/libs/planner/src/planScaleOut.c b/source/libs/planner/src/planScaleOut.c
index a0b63ad6ff..1f43d54333 100644
--- a/source/libs/planner/src/planScaleOut.c
+++ b/source/libs/planner/src/planScaleOut.c
@@ -82,29 +82,41 @@ static int32_t scaleOutByVgroups(SScaleOutContext* pCxt, SLogicSubplan* pSubplan
   return code;
 }
 
+static int32_t scaleOutForMerge(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pGroup) {
+  return nodesListStrictAppend(pGroup, (SNode*)singleCloneSubLogicPlan(pCxt, pSubplan, level));
+}
+
+static int32_t scaleOutForInsertValues(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level,
+                                       SNodeList* pGroup) {
+  SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode;
+  size_t                 numOfVgroups = taosArrayGetSize(pNode->pDataBlocks);
+  for (int32_t i = 0; i < numOfVgroups; ++i) {
+    SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
+    if (NULL == pNewSubplan) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    ((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks = (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i);
+    if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pGroup, (SNode*)pNewSubplan)) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t scaleOutForInsert(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pGroup) {
+  SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode;
+  if (NULL == pNode->node.pChildren) {
+    return scaleOutForInsertValues(pCxt, pSubplan, level, pGroup);
+  }
+  return scaleOutForMerge(pCxt, pSubplan, level, pGroup);
+}
+
 static int32_t scaleOutForModify(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pGroup) {
   SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode;
   if (MODIFY_TABLE_TYPE_DELETE == pNode->modifyType) {
     return scaleOutByVgroups(pCxt, pSubplan, level, pGroup);
-  } else {
-    size_t numOfVgroups = taosArrayGetSize(pNode->pDataBlocks);
-    for (int32_t i = 0; i < numOfVgroups; ++i) {
-      SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
-      if (NULL == pNewSubplan) {
-        return TSDB_CODE_OUT_OF_MEMORY;
-      }
-      ((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks =
-          (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i);
-      if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pGroup, (SNode*)pNewSubplan)) {
-        return TSDB_CODE_OUT_OF_MEMORY;
-      }
-    }
-    return TSDB_CODE_SUCCESS;
   }
-}
-
-static int32_t scaleOutForMerge(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pGroup) {
-  return nodesListStrictAppend(pGroup, (SNode*)singleCloneSubLogicPlan(pCxt, pSubplan, level));
+  return scaleOutForInsert(pCxt, pSubplan, level, pGroup);
 }
 
 static int32_t scaleOutForScan(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pGroup) {
diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c
index 7644fc3b19..0863b5f21f 100644
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
@@ -20,6 +20,7 @@
 #define SPLIT_FLAG_MASK(n) (1 << n)
 
 #define SPLIT_FLAG_STABLE_SPLIT SPLIT_FLAG_MASK(0)
+#define SPLIT_FLAG_INSERT_SPLIT SPLIT_FLAG_MASK(1)
 
 #define SPLIT_FLAG_SET_MASK(val, mask)  (val) |= (mask)
 #define SPLIT_FLAG_TEST_MASK(val, mask) (((val) & (mask)) != 0)
@@ -1196,6 +1197,41 @@ static int32_t smaIndexSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
   return code;
 }
 
+typedef struct SInsertSelectSplitInfo {
+  SLogicNode*    pQueryRoot;
+  SLogicSubplan* pSubplan;
+} SInsertSelectSplitInfo;
+
+static bool insSelSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pNode,
+                                   SInsertSelectSplitInfo* pInfo) {
+  if (QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY == nodeType(pNode) && 1 == LIST_LENGTH(pNode->pChildren) &&
+      MODIFY_TABLE_TYPE_INSERT == ((SVnodeModifyLogicNode*)pNode)->modifyType) {
+    pInfo->pQueryRoot = (SLogicNode*)nodesListGetNode(pNode->pChildren, 0);
+    pInfo->pSubplan = pSubplan;
+    return true;
+  }
+  return false;
+}
+
+static int32_t insertSelectSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
+  SInsertSelectSplitInfo info = {0};
+  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_INSERT_SPLIT, (FSplFindSplitNode)insSelSplFindSplitNode, &info)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t code = splCreateExchangeNodeForSubplan(pCxt, info.pSubplan, info.pQueryRoot, info.pSubplan->subplanType);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)splCreateScanSubplan(pCxt, info.pQueryRoot, 0));
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    info.pSubplan->subplanType = SUBPLAN_TYPE_MODIFY;
+    SPLIT_FLAG_SET_MASK(info.pSubplan->splitFlag, SPLIT_FLAG_INSERT_SPLIT);
+  }
+  ++(pCxt->groupId);
+  pCxt->split = true;
+  return code;
+}
+
 typedef struct SQnodeSplitInfo {
   SLogicNode*    pSplitNode;
   SLogicSubplan* pSubplan;
@@ -1249,7 +1285,8 @@ static const SSplitRule splitRuleSet[] = {
   {.pName = "SingleTableJoinSplit", .splitFunc = singleTableJoinSplit},
   {.pName = "UnionAllSplit",        .splitFunc = unionAllSplit},
   {.pName = "UnionDistinctSplit",   .splitFunc = unionDistinctSplit},
-  {.pName = "SmaIndexSplit",        .splitFunc = smaIndexSplit}
+  {.pName = "SmaIndexSplit",        .splitFunc = smaIndexSplit},
+  {.pName = "InsertSelectSplit",    .splitFunc = insertSelectSplit}
 };
 // clang-format on
 
@@ -1258,7 +1295,11 @@ static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule));
 static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
   char* pStr = NULL;
   nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
-  qDebugL("apply split %s rule: %s", pRuleName, pStr);
+  if (NULL == pRuleName) {
+    qDebugL("before split: %s", pStr);
+  } else {
+    qDebugL("apply split %s rule: %s", pRuleName, pStr);
+  }
   taosMemoryFree(pStr);
 }
 
@@ -1266,6 +1307,7 @@ static int32_t applySplitRule(SPlanContext* pCxt, SLogicSubplan* pSubplan) {
   SSplitContext cxt = {
       .pPlanCxt = pCxt, .queryId = pSubplan->id.queryId, .groupId = pSubplan->id.groupId + 1, .split = false};
   bool split = false;
+  dumpLogicSubplan(NULL, pSubplan);
   do {
     split = false;
     for (int32_t i = 0; i < splitRuleNum; ++i) {
@@ -1293,8 +1335,16 @@ static void setVgroupsInfo(SLogicNode* pNode, SLogicSubplan* pSubplan) {
   FOREACH(pChild, pNode->pChildren) { setVgroupsInfo((SLogicNode*)pChild, pSubplan); }
 }
 
+static bool needSplitSubplan(SLogicSubplan* pLogicSubplan) {
+  if (QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY != nodeType(pLogicSubplan->pNode)) {
+    return true;
+  }
+  SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)pLogicSubplan->pNode;
+  return (MODIFY_TABLE_TYPE_INSERT == pModify->modifyType && NULL != pModify->node.pChildren);
+}
+
 int32_t splitLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) {
-  if (QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY == nodeType(pLogicSubplan->pNode)) {
+  if (!needSplitSubplan(pLogicSubplan)) {
     setVgroupsInfo(pLogicSubplan->pNode, pLogicSubplan);
     return TSDB_CODE_SUCCESS;
   }
diff --git a/source/libs/planner/test/planOtherTest.cpp b/source/libs/planner/test/planOtherTest.cpp
index 2c031aa3a8..7fd38cc5c8 100644
--- a/source/libs/planner/test/planOtherTest.cpp
+++ b/source/libs/planner/test/planOtherTest.cpp
@@ -91,3 +91,9 @@ TEST_F(PlanOtherTest, delete) {
 
   run("DELETE FROM st1 WHERE ts > now - 2d and ts < now - 1d AND tag1 = 10");
 }
+
+TEST_F(PlanOtherTest, insert) {
+  useDb("root", "test");
+
+  run("INSERT INTO t1 SELECT * FROM t1");
+}
diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c
index a3a15869eb..923224688c 100644
--- a/source/libs/qcom/src/queryUtil.c
+++ b/source/libs/qcom/src/queryUtil.c
@@ -171,17 +171,17 @@ char* jobTaskStatusStr(int32_t status) {
   switch (status) {
     case JOB_TASK_STATUS_NULL:
       return "NULL";
-    case JOB_TASK_STATUS_NOT_START:
-      return "NOT_START";
-    case JOB_TASK_STATUS_EXECUTING:
+    case JOB_TASK_STATUS_INIT:
+      return "INIT";
+    case JOB_TASK_STATUS_EXEC:
       return "EXECUTING";
-    case JOB_TASK_STATUS_PARTIAL_SUCCEED:
+    case JOB_TASK_STATUS_PART_SUCC:
       return "PARTIAL_SUCCEED";
-    case JOB_TASK_STATUS_SUCCEED:
+    case JOB_TASK_STATUS_SUCC:
       return "SUCCEED";
-    case JOB_TASK_STATUS_FAILED:
+    case JOB_TASK_STATUS_FAIL:
       return "FAILED";
-    case JOB_TASK_STATUS_DROPPING:
+    case JOB_TASK_STATUS_DROP:
       return "DROPPING";
     default:
       break;
@@ -200,7 +200,7 @@ SSchema createSchema(int8_t type, int32_t bytes, col_id_t colId, const char* nam
   return s;
 }
 
-void destroyQueryExecRes(SQueryExecRes* pRes) {
+void destroyQueryExecRes(SExecResult* pRes) {
   if (NULL == pRes || NULL == pRes->res) {
     return;
   }
diff --git a/source/libs/qworker/inc/qwInt.h b/source/libs/qworker/inc/qwInt.h
index 6faffa13b3..eb10a2fdd6 100644
--- a/source/libs/qworker/inc/qwInt.h
+++ b/source/libs/qworker/inc/qwInt.h
@@ -226,8 +226,8 @@ typedef struct SQWorkerMgmt {
 #define QW_TASK_NOT_EXIST(code)     (TSDB_CODE_QRY_SCH_NOT_EXIST == (code) || TSDB_CODE_QRY_TASK_NOT_EXIST == (code))
 #define QW_TASK_ALREADY_EXIST(code) (TSDB_CODE_QRY_TASK_ALREADY_EXIST == (code))
 #define QW_TASK_READY(status)                                                                                      \
-  (status == JOB_TASK_STATUS_SUCCEED || status == JOB_TASK_STATUS_FAILED || status == JOB_TASK_STATUS_CANCELLED || \
-   status == JOB_TASK_STATUS_PARTIAL_SUCCEED)
+  (status == JOB_TASK_STATUS_SUCC || status == JOB_TASK_STATUS_FAIL || status == JOB_TASK_STATUS_CANCELLED || \
+   status == JOB_TASK_STATUS_PART_SUCC)
 #define QW_SET_QTID(id, qId, tId, eId)                              \
   do {                                                              \
     *(uint64_t *)(id) = (qId);                                      \
diff --git a/source/libs/qworker/src/qwDbg.c b/source/libs/qworker/src/qwDbg.c
index 68058334ab..dfe5a04d19 100644
--- a/source/libs/qworker/src/qwDbg.c
+++ b/source/libs/qworker/src/qwDbg.c
@@ -19,7 +19,7 @@ int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus,
   int32_t code = 0;
 
   if (oriStatus == newStatus) {
-    if (newStatus == JOB_TASK_STATUS_EXECUTING || newStatus == JOB_TASK_STATUS_FAILED) {
+    if (newStatus == JOB_TASK_STATUS_EXEC || newStatus == JOB_TASK_STATUS_FAIL) {
       *ignore = true;
       return TSDB_CODE_SUCCESS;
     }
@@ -29,47 +29,47 @@ int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus,
 
   switch (oriStatus) {
     case JOB_TASK_STATUS_NULL:
-      if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_FAILED &&
-          newStatus != JOB_TASK_STATUS_NOT_START) {
+      if (newStatus != JOB_TASK_STATUS_EXEC && newStatus != JOB_TASK_STATUS_FAIL &&
+          newStatus != JOB_TASK_STATUS_INIT) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
 
       break;
-    case JOB_TASK_STATUS_NOT_START:
-      if (newStatus != JOB_TASK_STATUS_DROPPING && newStatus != JOB_TASK_STATUS_EXECUTING
-        && newStatus != JOB_TASK_STATUS_FAILED) {
+    case JOB_TASK_STATUS_INIT:
+      if (newStatus != JOB_TASK_STATUS_DROP && newStatus != JOB_TASK_STATUS_EXEC
+        && newStatus != JOB_TASK_STATUS_FAIL) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
 
       break;
-    case JOB_TASK_STATUS_EXECUTING:
-      if (newStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED && newStatus != JOB_TASK_STATUS_SUCCEED &&
-          newStatus != JOB_TASK_STATUS_FAILED && newStatus != JOB_TASK_STATUS_DROPPING) {
+    case JOB_TASK_STATUS_EXEC:
+      if (newStatus != JOB_TASK_STATUS_PART_SUCC && newStatus != JOB_TASK_STATUS_SUCC &&
+          newStatus != JOB_TASK_STATUS_FAIL && newStatus != JOB_TASK_STATUS_DROP) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
 
       break;
-    case JOB_TASK_STATUS_PARTIAL_SUCCEED:
-      if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_SUCCEED &&
-          newStatus != JOB_TASK_STATUS_FAILED && newStatus != JOB_TASK_STATUS_DROPPING) {
+    case JOB_TASK_STATUS_PART_SUCC:
+      if (newStatus != JOB_TASK_STATUS_EXEC && newStatus != JOB_TASK_STATUS_SUCC &&
+          newStatus != JOB_TASK_STATUS_FAIL && newStatus != JOB_TASK_STATUS_DROP) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
 
       break;
-    case JOB_TASK_STATUS_SUCCEED:
-      if (newStatus != JOB_TASK_STATUS_DROPPING && newStatus != JOB_TASK_STATUS_FAILED) {
+    case JOB_TASK_STATUS_SUCC:
+      if (newStatus != JOB_TASK_STATUS_DROP && newStatus != JOB_TASK_STATUS_FAIL) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
 
       break;
-    case JOB_TASK_STATUS_FAILED:
-      if (newStatus != JOB_TASK_STATUS_DROPPING) {
+    case JOB_TASK_STATUS_FAIL:
+      if (newStatus != JOB_TASK_STATUS_DROP) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
       break;
 
-    case JOB_TASK_STATUS_DROPPING:
-      if (newStatus != JOB_TASK_STATUS_FAILED && newStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED) {
+    case JOB_TASK_STATUS_DROP:
+      if (newStatus != JOB_TASK_STATUS_FAIL && newStatus != JOB_TASK_STATUS_PART_SUCC) {
         QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
       }
       break;
diff --git a/source/libs/qworker/src/qwUtil.c b/source/libs/qworker/src/qwUtil.c
index 1fb0a34314..5aaf2b8038 100644
--- a/source/libs/qworker/src/qwUtil.c
+++ b/source/libs/qworker/src/qwUtil.c
@@ -433,8 +433,8 @@ void qwSetHbParam(int64_t refId, SQWHbParam **pParam) {
 }
 
 void qwSaveTbVersionInfo(qTaskInfo_t pTaskInfo, SQWTaskCtx *ctx) {
-  char dbFName[TSDB_DB_FNAME_LEN];
-  char tbName[TSDB_TABLE_NAME_LEN];
+  char dbFName[TSDB_DB_FNAME_LEN] = {0};
+  char tbName[TSDB_TABLE_NAME_LEN] = {0};
 
   qGetQueriedTableSchemaVersion(pTaskInfo, dbFName, tbName, &ctx->tbInfo.sversion, &ctx->tbInfo.tversion);
 
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 9a5a3d1bc9..5ba525329f 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -206,7 +206,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 
       QW_TASK_DLOG_E("no data in sink and query end");
 
-      qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCCEED);
+      qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC);
       QW_ERR_RET(qwMallocFetchRsp(len, &rsp));
 
       *rspMsg = rsp;
@@ -236,7 +236,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 
   if (DS_BUF_EMPTY == pOutput->bufStatus && pOutput->queryEnd) {
     QW_TASK_DLOG_E("task all data fetched, done");
-    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCCEED);
+    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -319,7 +319,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu
         break;
       }
 
-      QW_ERR_JRET(qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXECUTING));
+      QW_ERR_JRET(qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC));
       break;
     }
     case QW_PHASE_PRE_FETCH: {
@@ -436,7 +436,7 @@ int32_t qwHandlePostPhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inp
 _return:
 
   if (TSDB_CODE_SUCCESS == code && QW_PHASE_POST_QUERY == phase) {
-    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_PARTIAL_SUCCEED);
+    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_PART_SUCC);
   }
 
   if (rspConnection) {
@@ -456,7 +456,7 @@ _return:
   }
 
   if (code) {
-    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAILED);
+    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL);
   }
 
   QW_TASK_DLOG("end to handle event at phase %s, code:%x - %s", qwPhaseStr(phase), code, tstrerror(code));
@@ -488,7 +488,7 @@ int32_t qwPrerocessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
 
   ctx->ctrlConnInfo = qwMsg->connInfo;
 
-  QW_ERR_JRET(qwAddTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_NOT_START));
+  QW_ERR_JRET(qwAddTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_INIT));
 
 _return:
 
@@ -687,7 +687,7 @@ int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
     if (QW_IS_QUERY_RUNNING(ctx)) {
       atomic_store_8((int8_t *)&ctx->queryContinue, 1);
     } else if (0 == atomic_load_8((int8_t *)&ctx->queryInQueue)) {
-      qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXECUTING);
+      qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC);
 
       atomic_store_8((int8_t *)&ctx->queryInQueue, 1);
 
@@ -738,7 +738,7 @@ int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
 
   if (QW_IS_QUERY_RUNNING(ctx)) {
     QW_ERR_JRET(qwKillTaskHandle(QW_FPARAMS(), ctx));
-    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_DROPPING);
+    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_DROP);
   } else if (ctx->phase > 0) {
     QW_ERR_JRET(qwDropTask(QW_FPARAMS()));
     rsped = true;
@@ -759,7 +759,7 @@ _return:
       QW_UPDATE_RSP_CODE(ctx, code);
     }
 
-    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAILED);
+    qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL);
   }
 
   if (locked) {
diff --git a/source/libs/scheduler/inc/schedulerInt.h b/source/libs/scheduler/inc/schInt.h
similarity index 81%
rename from source/libs/scheduler/inc/schedulerInt.h
rename to source/libs/scheduler/inc/schInt.h
index cf6acc5843..8e8652aab5 100644
--- a/source/libs/scheduler/inc/schedulerInt.h
+++ b/source/libs/scheduler/inc/schInt.h
@@ -52,6 +52,7 @@ typedef enum {
   SCH_OP_NULL = 0,
   SCH_OP_EXEC,
   SCH_OP_FETCH,
+  SCH_OP_GET_STATUS,
 } SCH_OP_TYPE;
 
 typedef struct SSchTrans {
@@ -97,13 +98,30 @@ typedef struct SSchStat {
 } SSchStat;
 
 typedef struct SSchResInfo {
-  SQueryResult*          queryRes;
+  SExecResult*           execRes;
   void**                 fetchRes;
   schedulerExecFp        execFp; 
   schedulerFetchFp       fetchFp; 
-  void*                  userParam;
+  void*                  cbParam;
 } SSchResInfo;
 
+typedef struct SSchOpEvent {
+  SCH_OP_TYPE    type;
+  bool           begin;
+  SSchedulerReq *pReq;
+} SSchOpEvent;
+
+typedef int32_t (*schStatusEnterFp)(void* pHandle, void* pParam);
+typedef int32_t (*schStatusLeaveFp)(void* pHandle, void* pParam);
+typedef int32_t (*schStatusEventFp)(void* pHandle, void* pParam, void* pEvent);
+
+typedef struct SSchStatusFps {
+  EJobTaskType     status;
+  schStatusEnterFp enterFp;
+  schStatusLeaveFp leaveFp;
+  schStatusEventFp eventFp;
+} SSchStatusFps;
+
 typedef struct SSchedulerMgmt {
   uint64_t        taskId; // sequential taksId
   uint64_t        sId;    // schedulerId
@@ -157,7 +175,7 @@ typedef struct SSchLevel {
   int32_t         taskNum;
   int32_t         taskLaunchedNum;
   int32_t         taskDoneNum;
-  SArray         *subTasks;      // Element is SQueryTask
+  SArray         *subTasks;      // Element is SSchTask
 } SSchLevel;
 
 typedef struct SSchTaskProfile {
@@ -195,12 +213,13 @@ typedef struct SSchTask {
 typedef struct SSchJobAttr {
   EExplainMode explainMode;
   bool         queryJob;
+  bool         needFetch;
   bool         needFlowCtrl;
 } SSchJobAttr;
 
 typedef struct {
   int32_t     op;
-  bool        sync;
+  bool        syncReq;
 } SSchOpStatus;
 
 typedef struct SSchJob {
@@ -231,7 +250,7 @@ typedef struct SSchJob {
   SSchTask          *fetchTask;
   int32_t            errCode;
   SRWLatch           resLock;
-  SQueryExecRes      execRes;
+  SExecResult        execRes;
   void              *resData;         //TODO free it or not
   int32_t            resNumOfRows;
   SSchResInfo        userRes;
@@ -292,19 +311,19 @@ extern SSchedulerMgmt schMgmt;
 #define SCH_GET_JOB_STATUS(job) atomic_load_8(&(job)->status)
 #define SCH_GET_JOB_STATUS_STR(job) jobTaskStatusStr(SCH_GET_JOB_STATUS(job))
 
-#define SCH_JOB_IN_SYNC_OP(job) ((job)->opStatus.op && (job)->opStatus.sync)
-#define SCH_JOB_IN_ASYNC_EXEC_OP(job) (((job)->opStatus.op == SCH_OP_EXEC) && (!(job)->opStatus.sync))
-#define SCH_JOB_IN_ASYNC_FETCH_OP(job) (((job)->opStatus.op == SCH_OP_FETCH) && (!(job)->opStatus.sync))
+#define SCH_JOB_IN_SYNC_OP(job) ((job)->opStatus.op && (job)->opStatus.syncReq)
+#define SCH_JOB_IN_ASYNC_EXEC_OP(job) ((SCH_OP_EXEC == atomic_val_compare_exchange_32(&(job)->opStatus.op, SCH_OP_EXEC, SCH_OP_NULL)) && (!(job)->opStatus.syncReq))
+#define SCH_JOB_IN_ASYNC_FETCH_OP(job) ((SCH_OP_FETCH == atomic_val_compare_exchange_32(&(job)->opStatus.op, SCH_OP_FETCH, SCH_OP_NULL)) && (!(job)->opStatus.syncReq))
 
 #define SCH_SET_JOB_NEED_FLOW_CTRL(_job) (_job)->attr.needFlowCtrl = true
 #define SCH_JOB_NEED_FLOW_CTRL(_job) ((_job)->attr.needFlowCtrl)
 #define SCH_TASK_NEED_FLOW_CTRL(_job, _task) (SCH_IS_DATA_SRC_QRY_TASK(_task) && SCH_JOB_NEED_FLOW_CTRL(_job) && SCH_IS_LEVEL_UNFINISHED((_task)->level))
 
-#define SCH_SET_JOB_TYPE(_job, type) (_job)->attr.queryJob = ((type) != SUBPLAN_TYPE_MODIFY)
+#define SCH_SET_JOB_TYPE(_job, type) do { if ((type) != SUBPLAN_TYPE_MODIFY) { (_job)->attr.queryJob = true; } } while (0)
 #define SCH_IS_QUERY_JOB(_job) ((_job)->attr.queryJob) 
-#define SCH_JOB_NEED_FETCH(_job) SCH_IS_QUERY_JOB(_job)
-#define SCH_IS_WAIT_ALL_JOB(_job) (!SCH_IS_QUERY_JOB(_job))
-#define SCH_IS_NEED_DROP_JOB(_job) (SCH_IS_QUERY_JOB(_job))
+#define SCH_JOB_NEED_FETCH(_job) ((_job)->attr.needFetch)
+#define SCH_JOB_NEED_WAIT(_job) (!SCH_IS_QUERY_JOB(_job))
+#define SCH_JOB_NEED_DROP(_job) (SCH_IS_QUERY_JOB(_job))
 #define SCH_IS_EXPLAIN_JOB(_job) (EXPLAIN_MODE_ANALYZE == (_job)->attr.explainMode)
 #define SCH_NETWORK_ERR(_code) ((_code) == TSDB_CODE_RPC_BROKEN_LINK || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL)
 #define SCH_SUB_TASK_NETWORK_ERR(_code, _len) (SCH_NETWORK_ERR(_code) && ((_len) > 0))
@@ -329,9 +348,10 @@ extern SSchedulerMgmt schMgmt;
 #define SCH_TASK_WLOG(param, ...) \
   qWarn("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask),__VA_ARGS__)
 
-#define SCH_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
-#define SCH_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
-#define SCH_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
+#define SCH_SET_ERRNO(_err) do { if (TSDB_CODE_SCH_IGNORE_ERROR != (_err)) { terrno = (_err); } } while (0)
+#define SCH_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { SCH_SET_ERRNO(_code); return _code; } } while (0)
+#define SCH_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { SCH_SET_ERRNO(_code); } return _code; } while (0)
+#define SCH_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { SCH_SET_ERRNO(code); goto _return; } } while (0)
 
 #define SCH_LOCK(type, _lock) (SCH_READ == (type) ? taosRLockLatch(_lock) : taosWLockLatch(_lock))
 #define SCH_UNLOCK(type, _lock) (SCH_READ == (type) ? taosRUnLockLatch(_lock) : taosWUnLockLatch(_lock))
@@ -349,7 +369,7 @@ int32_t schDecTaskFlowQuota(SSchJob *pJob, SSchTask *pTask);
 int32_t schCheckIncTaskFlowQuota(SSchJob *pJob, SSchTask *pTask, bool *enough);
 int32_t schLaunchTasksInFlowCtrlList(SSchJob *pJob, SSchTask *pTask);
 int32_t schLaunchTaskImpl(SSchJob *pJob, SSchTask *pTask);
-int32_t schFetchFromRemote(SSchJob *pJob);
+int32_t schLaunchFetchTask(SSchJob *pJob);
 int32_t schProcessOnTaskFailure(SSchJob *pJob, SSchTask *pTask, int32_t errCode);
 int32_t schBuildAndSendHbMsg(SQueryNodeEpId *nodeEpId, SArray* taskAction);
 int32_t schCloneSMsgSendInfo(void *src, void **dst);
@@ -371,25 +391,45 @@ void    schFreeRpcCtxVal(const void *arg);
 int32_t schMakeBrokenLinkVal(SSchJob *pJob, SSchTask *pTask, SRpcBrokenlinkVal *brokenVal, bool isHb);
 int32_t schAppendTaskExecNode(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, int32_t execId);
 int32_t schExecStaticExplainJob(SSchedulerReq *pReq, int64_t *job, bool sync);
-int32_t schExecJobImpl(SSchedulerReq *pReq, SSchJob *pJob, bool sync);
 int32_t schUpdateJobStatus(SSchJob *pJob, int8_t newStatus);
 int32_t schCancelJob(SSchJob *pJob);
 int32_t schProcessOnJobDropped(SSchJob *pJob, int32_t errCode);
 uint64_t schGenTaskId(void);
 void    schCloseJobRef(void);
-int32_t schExecJob(SSchedulerReq *pReq, int64_t *pJob, SQueryResult *pRes);
 int32_t schAsyncExecJob(SSchedulerReq *pReq, int64_t *pJob);
-int32_t schFetchRows(SSchJob *pJob);
-int32_t schAsyncFetchRows(SSchJob *pJob);
+int32_t schJobFetchRows(SSchJob *pJob);
+int32_t schJobFetchRowsA(SSchJob *pJob);
 int32_t schUpdateTaskHandle(SSchJob *pJob, SSchTask *pTask, bool dropExecNode, void *handle, int32_t execId);
 int32_t schProcessOnTaskStatusRsp(SQueryNodeEpId* pEpId, SArray* pStatusList);
 void    schFreeSMsgSendInfo(SMsgSendInfo *msgSendInfo);
 char*   schGetOpStr(SCH_OP_TYPE type);
 int32_t schBeginOperation(SSchJob *pJob, SCH_OP_TYPE type, bool sync);
-int32_t schInitJob(SSchedulerReq *pReq, SSchJob **pSchJob);
-int32_t schSetJobQueryRes(SSchJob* pJob, SQueryResult* pRes);
+int32_t schInitJob(int64_t *pJobId, SSchedulerReq *pReq);
+int32_t schExecJob(SSchJob *pJob, SSchedulerReq *pReq);
+int32_t schDumpJobExecRes(SSchJob* pJob, SExecResult* pRes);
 int32_t schUpdateTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask, SEpSet* pEpSet);
 int32_t schHandleRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32_t rspCode);
+void    schProcessOnOpEnd(SSchJob *pJob, SCH_OP_TYPE type, SSchedulerReq* pReq, int32_t errCode);
+int32_t schProcessOnOpBegin(SSchJob* pJob, SCH_OP_TYPE type, SSchedulerReq* pReq);
+void    schProcessOnCbEnd(SSchJob *pJob, SSchTask *pTask, int32_t errCode);
+int32_t schProcessOnCbBegin(SSchJob** job, SSchTask** task, uint64_t qId, int64_t rId, uint64_t tId);
+void    schDropTaskOnExecNode(SSchJob *pJob, SSchTask *pTask);
+bool    schJobDone(SSchJob *pJob);
+int32_t schRemoveTaskFromExecList(SSchJob *pJob, SSchTask *pTask);
+int32_t schLaunchJobLowerLevel(SSchJob *pJob, SSchTask *pTask);
+int32_t schSwitchJobStatus(SSchJob* pJob, int32_t status, void* param);
+int32_t schHandleOpBeginEvent(int64_t jobId, SSchJob** job, SCH_OP_TYPE type, SSchedulerReq* pReq);
+int32_t schHandleOpEndEvent(SSchJob* pJob, SCH_OP_TYPE type, SSchedulerReq* pReq, int32_t errCode);
+int32_t schHandleTaskRetry(SSchJob *pJob, SSchTask *pTask);
+void    schUpdateJobErrCode(SSchJob *pJob, int32_t errCode);
+int32_t schTaskCheckSetRetry(SSchJob *pJob, SSchTask *pTask, int32_t errCode, bool *needRetry);
+int32_t schProcessOnJobFailure(SSchJob *pJob, int32_t errCode);
+int32_t schProcessOnJobPartialSuccess(SSchJob *pJob);
+void    schFreeTask(SSchJob *pJob, SSchTask *pTask);
+void    schDropTaskInHashList(SSchJob *pJob, SHashObj *list);
+int32_t schLaunchLevelTasks(SSchJob *pJob, SSchLevel *level);
+int32_t schGetTaskFromList(SHashObj *pTaskList, uint64_t taskId, SSchTask **pTask);
+int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel);
 
 
 #ifdef __cplusplus
diff --git a/source/libs/scheduler/src/schDbg.c b/source/libs/scheduler/src/schDbg.c
index 5c0c6fbb76..7f013b8f32 100644
--- a/source/libs/scheduler/src/schDbg.c
+++ b/source/libs/scheduler/src/schDbg.c
@@ -14,16 +14,16 @@
  */
 
 #include "query.h"
-#include "schedulerInt.h"
+#include "schInt.h"
 
 tsem_t schdRspSem;
 
-void schdExecCallback(SQueryResult* pResult, void* param, int32_t code) {
+void schdExecCallback(SExecResult* pResult, void* param, int32_t code) {
   if (code) {
     pResult->code = code;
   }
   
-  *(SQueryResult*)param = *pResult;
+  *(SExecResult*)param = *pResult;
 
   taosMemoryFree(pResult);
 
diff --git a/source/libs/scheduler/src/schFlowCtrl.c b/source/libs/scheduler/src/schFlowCtrl.c
index 85d205f5f2..6b34a394b6 100644
--- a/source/libs/scheduler/src/schFlowCtrl.c
+++ b/source/libs/scheduler/src/schFlowCtrl.c
@@ -13,7 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "tmsg.h"
 #include "query.h"
 #include "catalog.h"
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index 56ebc21568..858f68e7ae 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -16,135 +16,11 @@
 #include "catalog.h"
 #include "command.h"
 #include "query.h"
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "tmsg.h"
 #include "tref.h"
 #include "trpc.h"
 
-FORCE_INLINE SSchJob *schAcquireJob(int64_t refId) { qDebug("sch acquire jobId:0x%"PRIx64, refId); return (SSchJob *)taosAcquireRef(schMgmt.jobRef, refId); }
-
-FORCE_INLINE int32_t schReleaseJob(int64_t refId) { qDebug("sch release jobId:0x%"PRIx64, refId); return taosReleaseRef(schMgmt.jobRef, refId); }
-
-int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel) {
-  pTask->plan = pPlan;
-  pTask->level = pLevel;
-  pTask->execId = -1;
-  pTask->maxExecTimes = SCH_TASK_MAX_EXEC_TIMES;
-  pTask->timeoutUsec = SCH_DEFAULT_TASK_TIMEOUT_USEC;
-  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_NOT_START);
-  pTask->taskId = schGenTaskId();
-  pTask->execNodes = taosHashInit(SCH_MAX_CANDIDATE_EP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (NULL == pTask->execNodes) {
-    SCH_TASK_ELOG("taosHashInit %d execNodes failed", SCH_MAX_CANDIDATE_EP_NUM);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schInitJob(SSchedulerReq *pReq, SSchJob **pSchJob) {
-  int32_t  code = 0;
-  int64_t  refId = -1;
-  SSchJob *pJob = taosMemoryCalloc(1, sizeof(SSchJob));
-  if (NULL == pJob) {
-    qError("QID:0x%" PRIx64 " calloc %d failed", pReq->pDag->queryId, (int32_t)sizeof(SSchJob));
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  pJob->attr.explainMode = pReq->pDag->explainInfo.mode;
-  pJob->conn = *pReq->pConn;
-  pJob->sql = pReq->sql;
-  pJob->pDag = pReq->pDag;
-  pJob->chkKillFp = pReq->chkKillFp;
-  pJob->chkKillParam = pReq->chkKillParam;
-  pJob->userRes.execFp = pReq->execFp;
-  pJob->userRes.userParam = pReq->execParam;
-
-  if (pReq->pNodeList == NULL || taosArrayGetSize(pReq->pNodeList) <= 0) {
-    qDebug("QID:0x%" PRIx64 " input exec nodeList is empty", pReq->pDag->queryId);
-  } else {
-    pJob->nodeList = taosArrayDup(pReq->pNodeList);
-  }
-  
-  pJob->taskList =
-      taosHashInit(pReq->pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
-  if (NULL == pJob->taskList) {
-    SCH_JOB_ELOG("taosHashInit %d taskList failed", pReq->pDag->numOfSubplans);
-    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  SCH_ERR_JRET(schValidateAndBuildJob(pReq->pDag, pJob));
-
-  if (SCH_IS_EXPLAIN_JOB(pJob)) {
-    SCH_ERR_JRET(qExecExplainBegin(pReq->pDag, &pJob->explainCtx, pReq->startTs));
-  }
-
-  pJob->execTasks =
-      taosHashInit(pReq->pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
-  if (NULL == pJob->execTasks) {
-    SCH_JOB_ELOG("taosHashInit %d execTasks failed", pReq->pDag->numOfSubplans);
-    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  tsem_init(&pJob->rspSem, 0, 0);
-
-  refId = taosAddRef(schMgmt.jobRef, pJob);
-  if (refId < 0) {
-    SCH_JOB_ELOG("taosAddRef job failed, error:%s", tstrerror(terrno));
-    SCH_ERR_JRET(terrno);
-  }
-
-  atomic_add_fetch_32(&schMgmt.jobNum, 1);
-
-  if (NULL == schAcquireJob(refId)) {
-    SCH_JOB_ELOG("schAcquireJob job failed, refId:0x%" PRIx64, refId);
-    SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
-
-  pJob->refId = refId;
-
-  SCH_JOB_DLOG("job refId:0x%" PRIx64" created", pJob->refId);
-
-  schUpdateJobStatus(pJob, JOB_TASK_STATUS_NOT_START);
-
-  *pSchJob = pJob;
-
-  return TSDB_CODE_SUCCESS;
-
-_return:
-
-  if (refId < 0) {
-    schFreeJobImpl(pJob);
-  } else {
-    taosRemoveRef(schMgmt.jobRef, refId);
-  }
-  SCH_RET(code);
-}
-
-
-void schFreeTask(SSchJob *pJob, SSchTask *pTask) {
-  schDeregisterTaskHb(pJob, pTask);
-  
-  if (pTask->candidateAddrs) {
-    taosArrayDestroy(pTask->candidateAddrs);
-  }
-
-  taosMemoryFreeClear(pTask->msg);
-
-  if (pTask->children) {
-    taosArrayDestroy(pTask->children);
-  }
-
-  if (pTask->parents) {
-    taosArrayDestroy(pTask->parents);
-  }
-
-  if (pTask->execNodes) {
-    taosHashCleanup(pTask->execNodes);
-  }
-}
-
-
 void schUpdateJobErrCode(SSchJob *pJob, int32_t errCode) {
   if (TSDB_CODE_SUCCESS == errCode) {
     return;
@@ -175,7 +51,12 @@ _return:
   SCH_JOB_DLOG("job errCode updated to %x - %s", errCode, tstrerror(errCode));
 }
 
-
+bool schJobDone(SSchJob *pJob) {
+  int8_t status = SCH_GET_JOB_STATUS(pJob);
+  
+  return (status == JOB_TASK_STATUS_FAIL || status == JOB_TASK_STATUS_DROP ||
+          status == JOB_TASK_STATUS_SUCC);
+}
 
 FORCE_INLINE bool schJobNeedToStop(SSchJob *pJob, int8_t *pStatus) {
   int8_t status = SCH_GET_JOB_STATUS(pJob);
@@ -183,13 +64,16 @@ FORCE_INLINE bool schJobNeedToStop(SSchJob *pJob, int8_t *pStatus) {
     *pStatus = status;
   }
 
+  if (schJobDone(pJob)) {
+    return true;
+  }
+
   if ((*pJob->chkKillFp)(pJob->chkKillParam)) {
     schUpdateJobErrCode(pJob, TSDB_CODE_TSC_QUERY_KILLED);
     return true;
-  }  
+  }
 
-  return (status == JOB_TASK_STATUS_FAILED || status == JOB_TASK_STATUS_DROPPING ||
-          status == JOB_TASK_STATUS_SUCCEED);
+  return false;
 }
 
 int32_t schUpdateJobStatus(SSchJob *pJob, int8_t newStatus) {
@@ -201,48 +85,44 @@ int32_t schUpdateJobStatus(SSchJob *pJob, int8_t newStatus) {
     oriStatus = SCH_GET_JOB_STATUS(pJob);
 
     if (oriStatus == newStatus) {
-      if (newStatus == JOB_TASK_STATUS_DROPPING) {
-        SCH_ERR_JRET(TSDB_CODE_SCH_JOB_IS_DROPPING);
-      }
-      
       SCH_ERR_JRET(TSDB_CODE_SCH_IGNORE_ERROR);
     }
 
     switch (oriStatus) {
       case JOB_TASK_STATUS_NULL:
-        if (newStatus != JOB_TASK_STATUS_NOT_START) {
+        if (newStatus != JOB_TASK_STATUS_INIT) {
           SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
         }
 
         break;
-      case JOB_TASK_STATUS_NOT_START:
-        if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_DROPPING) {
+      case JOB_TASK_STATUS_INIT:
+        if (newStatus != JOB_TASK_STATUS_EXEC && newStatus != JOB_TASK_STATUS_DROP) {
           SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
         }
 
         break;
-      case JOB_TASK_STATUS_EXECUTING:
-        if (newStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED && newStatus != JOB_TASK_STATUS_FAILED &&
-            newStatus != JOB_TASK_STATUS_DROPPING) {
+      case JOB_TASK_STATUS_EXEC:
+        if (newStatus != JOB_TASK_STATUS_PART_SUCC && newStatus != JOB_TASK_STATUS_FAIL &&
+            newStatus != JOB_TASK_STATUS_DROP) {
           SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
         }
 
         break;
-      case JOB_TASK_STATUS_PARTIAL_SUCCEED:
-        if (newStatus != JOB_TASK_STATUS_FAILED && newStatus != JOB_TASK_STATUS_SUCCEED &&
-            newStatus != JOB_TASK_STATUS_DROPPING) {
+      case JOB_TASK_STATUS_PART_SUCC:
+        if (newStatus != JOB_TASK_STATUS_FAIL && newStatus != JOB_TASK_STATUS_SUCC &&
+            newStatus != JOB_TASK_STATUS_DROP) {
           SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
         }
 
         break;
-      case JOB_TASK_STATUS_SUCCEED:
-      case JOB_TASK_STATUS_FAILED:
-        if (newStatus != JOB_TASK_STATUS_DROPPING) {
+      case JOB_TASK_STATUS_SUCC:
+      case JOB_TASK_STATUS_FAIL:
+        if (newStatus != JOB_TASK_STATUS_DROP) {
           SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
         }
 
         break;
-      case JOB_TASK_STATUS_DROPPING:
+      case JOB_TASK_STATUS_DROP:
         SCH_ERR_JRET(TSDB_CODE_QRY_JOB_FREED);
         break;
 
@@ -264,67 +144,11 @@ int32_t schUpdateJobStatus(SSchJob *pJob, int8_t newStatus) {
 
 _return:
 
-  SCH_JOB_ELOG("invalid job status update, from %s to %s", jobTaskStatusStr(oriStatus), jobTaskStatusStr(newStatus));
-  SCH_RET(code);
-}
-
-
-void schEndOperation(SSchJob *pJob) {
-  int32_t op = atomic_load_32(&pJob->opStatus.op);
-  if (SCH_OP_NULL == op) {
-    SCH_JOB_DLOG("job already not in any operation, status:%s", jobTaskStatusStr(pJob->status));
-    return;
+  if (TSDB_CODE_SCH_IGNORE_ERROR == code) {
+    SCH_JOB_DLOG("ignore job status update, from %s to %s", jobTaskStatusStr(oriStatus), jobTaskStatusStr(newStatus));
+  } else {
+    SCH_JOB_ELOG("invalid job status update, from %s to %s", jobTaskStatusStr(oriStatus), jobTaskStatusStr(newStatus));
   }
-
-  atomic_store_32(&pJob->opStatus.op, SCH_OP_NULL);
-  
-  SCH_JOB_DLOG("job end %s operation", schGetOpStr(op));
-}
-
-int32_t schBeginOperation(SSchJob *pJob, SCH_OP_TYPE type, bool sync) {
-  int32_t code = 0;
-  int8_t status = 0;
-  
-  if (schJobNeedToStop(pJob, &status)) {
-    SCH_JOB_ELOG("abort op %s cause of job need to stop", schGetOpStr(type));
-    SCH_ERR_JRET(pJob->errCode);
-  }
-      
-  if (SCH_OP_NULL != atomic_val_compare_exchange_32(&pJob->opStatus.op, SCH_OP_NULL, type)) {
-    SCH_JOB_ELOG("job already in %s operation", schGetOpStr(pJob->opStatus.op));
-    SCH_ERR_JRET(TSDB_CODE_TSC_APP_ERROR);
-  }
-
-  SCH_JOB_DLOG("job start %s operation", schGetOpStr(pJob->opStatus.op));
-
-  pJob->opStatus.sync = sync;
-
-  switch (type) {
-    case SCH_OP_EXEC:
-      SCH_ERR_JRET(schUpdateJobStatus(pJob, JOB_TASK_STATUS_EXECUTING));
-      break;
-    case SCH_OP_FETCH:
-      if (!SCH_JOB_NEED_FETCH(pJob)) {
-        SCH_JOB_ELOG("no need to fetch data, status:%s", SCH_GET_JOB_STATUS_STR(pJob));
-        SCH_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
-      }
-
-      if (status != JOB_TASK_STATUS_PARTIAL_SUCCEED) {
-        SCH_JOB_ELOG("job status error for fetch, status:%s", jobTaskStatusStr(status));
-        SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-      }
-      break;
-    default:
-      SCH_JOB_ELOG("unknown operation type %d", type);
-      SCH_ERR_JRET(TSDB_CODE_TSC_APP_ERROR);
-  }
-
-  return TSDB_CODE_SUCCESS;
-
-_return:
-
-  schEndOperation(pJob);
-
   SCH_RET(code);
 }
 
@@ -406,86 +230,23 @@ int32_t schBuildTaskRalation(SSchJob *pJob, SHashObj *planToTask) {
   }
 
   SSchLevel *pLevel = taosArrayGet(pJob->levels, 0);
-  if (SCH_IS_QUERY_JOB(pJob) && pLevel->taskNum > 1) {
-    SCH_JOB_ELOG("invalid query plan, level:0, taskNum:%d", pLevel->taskNum);
-    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
+  if (SCH_IS_QUERY_JOB(pJob)) {
+    if (pLevel->taskNum > 1) {
+      SCH_JOB_ELOG("invalid query plan, level:0, taskNum:%d", pLevel->taskNum);
+      SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
+    }
+
+    SSchTask* pTask = taosArrayGet(pLevel->subTasks, 0);
+    if (SUBPLAN_TYPE_MODIFY != pTask->plan->subplanType) {
+      pJob->attr.needFetch = true;
+    }
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schRecordTaskSucceedNode(SSchJob *pJob, SSchTask *pTask) {
-  SQueryNodeAddr *addr = taosArrayGet(pTask->candidateAddrs, pTask->candidateIdx);
-  if (NULL == addr) {
-    SCH_TASK_ELOG("taosArrayGet candidate addr failed, idx:%d, size:%d", pTask->candidateIdx,
-                  (int32_t)taosArrayGetSize(pTask->candidateAddrs));
-    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
-  }
 
-  pTask->succeedAddr = *addr;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schAppendTaskExecNode(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, int32_t execId) {
-  SSchNodeInfo nodeInfo = {.addr = *addr, .handle = NULL};
-
-  if (taosHashPut(pTask->execNodes, &execId, sizeof(execId), &nodeInfo, sizeof(nodeInfo))) {
-    SCH_TASK_ELOG("taosHashPut nodeInfo to execNodes failed, errno:%d", errno);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  SCH_TASK_DLOG("task execNode added, execId:%d", execId);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schDropTaskExecNode(SSchJob *pJob, SSchTask *pTask, void *handle, int32_t execId) {
-  if (NULL == pTask->execNodes) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (taosHashRemove(pTask->execNodes, &execId, sizeof(execId))) {
-    SCH_TASK_ELOG("fail to remove execId %d from execNodeList", execId);
-  } else {
-    SCH_TASK_DLOG("execId %d removed from execNodeList", execId);
-  }
-  
-  if (execId != pTask->execId) {     // ignore it
-    SCH_TASK_DLOG("execId %d is not current execId %d", execId, pTask->execId);
-    SCH_RET(TSDB_CODE_SCH_IGNORE_ERROR);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schUpdateTaskExecNode(SSchJob *pJob, SSchTask *pTask, void *handle, int32_t execId) {
-  if (taosHashGetSize(pTask->execNodes) <= 0) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SSchNodeInfo *nodeInfo = taosHashGet(pTask->execNodes, &execId, sizeof(execId));
-  nodeInfo->handle = handle;
-
-  SCH_TASK_DLOG("handle updated to %p for execId %d", handle, execId);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schUpdateTaskHandle(SSchJob *pJob, SSchTask *pTask, bool dropExecNode, void *handle, int32_t execId) {
-  if (dropExecNode) {
-    SCH_RET(schDropTaskExecNode(pJob, pTask, handle, execId));
-  }
-
-  SCH_SET_TASK_HANDLE(pTask, handle);
-
-  schUpdateTaskExecNode(pJob, pTask, handle, execId);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
-int32_t schRecordQueryDataSrc(SSchJob *pJob, SSchTask *pTask) {
+int32_t schAppendJobDataSrc(SSchJob *pJob, SSchTask *pTask) {
   if (!SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
     return TSDB_CODE_SUCCESS;
   }
@@ -539,7 +300,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
   int32_t        taskNum = 0;
   SSchLevel     *pLevel = NULL;
 
-  level.status = JOB_TASK_STATUS_NOT_START;
+  level.status = JOB_TASK_STATUS_INIT;
 
   for (int32_t i = 0; i < levelNum; ++i) {
     if (NULL == taosArrayPush(pJob->levels, &level)) {
@@ -584,7 +345,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
         SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
       }
 
-      SCH_ERR_JRET(schRecordQueryDataSrc(pJob, pTask));
+      SCH_ERR_JRET(schAppendJobDataSrc(pJob, pTask));
 
       if (0 != taosHashPut(planToTask, &plan, POINTER_BYTES, &pTask, POINTER_BYTES)) {
         SCH_TASK_ELOG("taosHashPut to planToTaks failed, taskIdx:%d", n);
@@ -613,292 +374,23 @@ _return:
   SCH_RET(code);
 }
 
-int32_t schSetAddrsFromNodeList(SSchJob *pJob, SSchTask *pTask) {
-  int32_t addNum = 0;
-  int32_t nodeNum = 0;
-  
-  if (pJob->nodeList) {
-    nodeNum = taosArrayGetSize(pJob->nodeList);
 
-    for (int32_t i = 0; i < nodeNum && addNum < SCH_MAX_CANDIDATE_EP_NUM; ++i) {
-      SQueryNodeLoad *nload = taosArrayGet(pJob->nodeList, i);
-      SQueryNodeAddr *naddr = &nload->addr;
-      
-      if (NULL == taosArrayPush(pTask->candidateAddrs, naddr)) {
-        SCH_TASK_ELOG("taosArrayPush execNode to candidate addrs failed, addNum:%d, errno:%d", addNum, errno);
-        SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-      }
-
-      SCH_TASK_DLOG("set %dth candidate addr, id %d, fqdn:%s, port:%d", i, naddr->nodeId, SCH_GET_CUR_EP(naddr)->fqdn, SCH_GET_CUR_EP(naddr)->port);
-
-      ++addNum;
-    }
-  }
-
-  if (addNum <= 0) {
-    SCH_TASK_ELOG("no available execNode as candidates, nodeNum:%d", nodeNum);
-    SCH_ERR_RET(TSDB_CODE_TSC_NO_EXEC_NODE);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
-int32_t schSetTaskCandidateAddrs(SSchJob *pJob, SSchTask *pTask) {
-  if (NULL != pTask->candidateAddrs) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  pTask->candidateIdx = 0;
-  pTask->candidateAddrs = taosArrayInit(SCH_MAX_CANDIDATE_EP_NUM, sizeof(SQueryNodeAddr));
-  if (NULL == pTask->candidateAddrs) {
-    SCH_TASK_ELOG("taosArrayInit %d condidate addrs failed", SCH_MAX_CANDIDATE_EP_NUM);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  if (pTask->plan->execNode.epSet.numOfEps > 0) {
-    if (NULL == taosArrayPush(pTask->candidateAddrs, &pTask->plan->execNode)) {
-      SCH_TASK_ELOG("taosArrayPush execNode to candidate addrs failed, errno:%d", errno);
-      SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-    }
-
-    SCH_TASK_DLOG("use execNode in plan as candidate addr, numOfEps:%d", pTask->plan->execNode.epSet.numOfEps);
-
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
-    SCH_TASK_ELOG("no execNode specifed for data src task, numOfEps:%d", pTask->plan->execNode.epSet.numOfEps);
-    SCH_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
-  }
-
-  SCH_ERR_RET(schSetAddrsFromNodeList(pJob, pTask));
-
-  /*
-    for (int32_t i = 0; i < job->dataSrcEps.numOfEps && addNum < SCH_MAX_CANDIDATE_EP_NUM; ++i) {
-      strncpy(epSet->fqdn[epSet->numOfEps], job->dataSrcEps.fqdn[i], sizeof(job->dataSrcEps.fqdn[i]));
-      epSet->port[epSet->numOfEps] = job->dataSrcEps.port[i];
-
-      ++epSet->numOfEps;
-    }
-  */
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schUpdateTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask, SEpSet* pEpSet) {
-  if (NULL == pTask->candidateAddrs || 1 != taosArrayGetSize(pTask->candidateAddrs)) {
-    SCH_TASK_ELOG("not able to update cndidate addr, addr num %d", (int32_t)(pTask->candidateAddrs ? taosArrayGetSize(pTask->candidateAddrs): 0));
-    SCH_ERR_RET(TSDB_CODE_APP_ERROR);
-  }
-
-  SQueryNodeAddr* pAddr = taosArrayGet(pTask->candidateAddrs, 0);
-
-  SEp* pOld = &pAddr->epSet.eps[pAddr->epSet.inUse];
-  SEp* pNew = &pEpSet->eps[pEpSet->inUse];
-
-  SCH_TASK_DLOG("update task ep from %s:%d to %s:%d", pOld->fqdn, pOld->port, pNew->fqdn, pNew->port);
-
-  memcpy(&pAddr->epSet, pEpSet, sizeof(pAddr->epSet));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
-int32_t schRemoveTaskFromExecList(SSchJob *pJob, SSchTask *pTask) {
-  int32_t code = taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId));
-  if (code) {
-    SCH_TASK_ELOG("task failed to rm from execTask list, code:%x", code);
-    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
-int32_t schPushTaskToExecList(SSchJob *pJob, SSchTask *pTask) {
-  int32_t code = taosHashPut(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
-  if (0 != code) {
-    if (HASH_NODE_EXIST(code)) {
-      SCH_TASK_ELOG("task already in execTask list, code:%x", code);
-      SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
-    }
-
-    SCH_TASK_ELOG("taosHashPut task to execTask list failed, errno:%d", errno);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  SCH_TASK_DLOG("task added to execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/*
-int32_t schMoveTaskToSuccList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
-  if (0 != taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId))) {
-    SCH_TASK_WLOG("remove task from execTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-  } else {
-    SCH_TASK_DLOG("task removed from execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
-  }
-
-  int32_t code = taosHashPut(pJob->succTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
-  if (0 != code) {
-    if (HASH_NODE_EXIST(code)) {
-      *moved = true;
-      SCH_TASK_ELOG("task already in succTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-    }
-
-    SCH_TASK_ELOG("taosHashPut task to succTask list failed, errno:%d", errno);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  *moved = true;
-
-  SCH_TASK_DLOG("task moved to succTask list, numOfTasks:%d", taosHashGetSize(pJob->succTasks));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schMoveTaskToFailList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
-  *moved = false;
-
-  if (0 != taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId))) {
-    SCH_TASK_WLOG("remove task from execTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-  }
-
-  int32_t code = taosHashPut(pJob->failTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
-  if (0 != code) {
-    if (HASH_NODE_EXIST(code)) {
-      *moved = true;
-
-      SCH_TASK_WLOG("task already in failTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-    }
-
-    SCH_TASK_ELOG("taosHashPut task to failTask list failed, errno:%d", errno);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  *moved = true;
-
-  SCH_TASK_DLOG("task moved to failTask list, numOfTasks:%d", taosHashGetSize(pJob->failTasks));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schMoveTaskToExecList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
-  if (0 != taosHashRemove(pJob->succTasks, &pTask->taskId, sizeof(pTask->taskId))) {
-    SCH_TASK_WLOG("remove task from succTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-  }
-
-  int32_t code = taosHashPut(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
-  if (0 != code) {
-    if (HASH_NODE_EXIST(code)) {
-      *moved = true;
-
-      SCH_TASK_ELOG("task already in execTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-    }
-
-    SCH_TASK_ELOG("taosHashPut task to execTask list failed, errno:%d", errno);
-    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
-  *moved = true;
-
-  SCH_TASK_DLOG("task moved to execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
-
-  return TSDB_CODE_SUCCESS;
-}
-*/
-
-int32_t schTaskCheckSetRetry(SSchJob *pJob, SSchTask *pTask, int32_t errCode, bool *needRetry) {
-  if (TSDB_CODE_SCH_TIMEOUT_ERROR == errCode) {
-    pTask->maxExecTimes++;
-    if (pTask->timeoutUsec < SCH_MAX_TASK_TIMEOUT_USEC) {
-      pTask->timeoutUsec *= 2;
-      if (pTask->timeoutUsec > SCH_MAX_TASK_TIMEOUT_USEC) {
-        pTask->timeoutUsec = SCH_MAX_TASK_TIMEOUT_USEC;
-      }
-    }
-  }
-
-  if ((pTask->execId + 1) >= pTask->maxExecTimes) {
-    *needRetry = false;
-    SCH_TASK_DLOG("task no more retry since reach max try times, execId:%d", pTask->execId);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (!SCH_NEED_RETRY(pTask->lastMsgType, errCode)) {
-    *needRetry = false;
-    SCH_TASK_DLOG("task no more retry cause of errCode, errCode:%x - %s", errCode, tstrerror(errCode));
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (SCH_IS_DATA_SRC_TASK(pTask)) {
-    if ((pTask->execId + 1) >= SCH_TASK_NUM_OF_EPS(&pTask->plan->execNode)) {
-      *needRetry = false;
-      SCH_TASK_DLOG("task no more retry since all ep tried, execId:%d, epNum:%d", pTask->execId,
-                    SCH_TASK_NUM_OF_EPS(&pTask->plan->execNode));
-      return TSDB_CODE_SUCCESS;
-    }
-  } else {
-    int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);
-
-    if ((pTask->candidateIdx + 1) >= candidateNum && (TSDB_CODE_SCH_TIMEOUT_ERROR != errCode)) {
-      *needRetry = false;
-      SCH_TASK_DLOG("task no more retry since all candiates tried, candidateIdx:%d, candidateNum:%d",
-                    pTask->candidateIdx, candidateNum);
-      return TSDB_CODE_SUCCESS;
-    }
-  }
-
-  *needRetry = true;
-  SCH_TASK_DLOG("task need the %dth retry, errCode:%x - %s", pTask->execId + 1, errCode, tstrerror(errCode));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schHandleTaskRetry(SSchJob *pJob, SSchTask *pTask) {
-  atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1);
-
-  SCH_ERR_RET(schRemoveTaskFromExecList(pJob, pTask));
-  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_NOT_START);
-  
-  if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
-    SCH_ERR_RET(schLaunchTasksInFlowCtrlList(pJob, pTask));
-  }
-
-  schDeregisterTaskHb(pJob, pTask);
-
-  if (SCH_IS_DATA_SRC_TASK(pTask)) {
-    SCH_SWITCH_EPSET(&pTask->plan->execNode);
-  } else {
-    int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);  
-    if (++pTask->candidateIdx >= candidateNum) {
-      pTask->candidateIdx = 0;
-    }
-  }
-
-  SCH_ERR_RET(schLaunchTask(pJob, pTask));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schSetJobQueryRes(SSchJob* pJob, SQueryResult* pRes) {
+int32_t schDumpJobExecRes(SSchJob* pJob, SExecResult* pRes) {
   pRes->code = atomic_load_32(&pJob->errCode);
   pRes->numOfRows = pJob->resNumOfRows;
-  pRes->res = pJob->execRes;
+  pRes->res = pJob->execRes.res;
+  pRes->msgType = pJob->execRes.msgType;
   pJob->execRes.res = NULL;
 
+  SCH_JOB_DLOG("execRes dumped, code: %s", tstrerror(pRes->code));
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schSetJobFetchRes(SSchJob* pJob, void** pData) {
+int32_t schDumpJobFetchRes(SSchJob* pJob, void** pData) {
   int32_t code = 0;
   if (pJob->resData && ((SRetrieveTableRsp *)pJob->resData)->completed) {
-    SCH_ERR_RET(schUpdateJobStatus(pJob, JOB_TASK_STATUS_SUCCEED));
+    SCH_ERR_RET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_SUCC, NULL));
   }
 
   while (true) {
@@ -926,16 +418,14 @@ int32_t schSetJobFetchRes(SSchJob* pJob, void** pData) {
 }
 
 int32_t schNotifyUserExecRes(SSchJob* pJob) {
-  SQueryResult* pRes = taosMemoryCalloc(1, sizeof(SQueryResult));
+  SExecResult* pRes = taosMemoryCalloc(1, sizeof(SExecResult));
   if (pRes) {
-    schSetJobQueryRes(pJob, pRes);
+    schDumpJobExecRes(pJob, pRes);
   }
 
-  schEndOperation(pJob);
-
   SCH_JOB_DLOG("sch start to invoke exec cb, code: %s", tstrerror(pJob->errCode));
-  (*pJob->userRes.execFp)(pRes, pJob->userRes.userParam, atomic_load_32(&pJob->errCode));
-  SCH_JOB_DLOG("sch end from query cb, code: %s", tstrerror(pJob->errCode));
+  (*pJob->userRes.execFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
+  SCH_JOB_DLOG("sch end from exec cb, code: %s", tstrerror(pJob->errCode));
 
   return TSDB_CODE_SUCCESS;
 }
@@ -943,12 +433,10 @@ int32_t schNotifyUserExecRes(SSchJob* pJob) {
 int32_t schNotifyUserFetchRes(SSchJob* pJob) {
   void* pRes = NULL;
   
-  schSetJobFetchRes(pJob, &pRes);
-
-  schEndOperation(pJob);
+  schDumpJobFetchRes(pJob, &pRes);
 
   SCH_JOB_DLOG("sch start to invoke fetch cb, code: %s", tstrerror(pJob->errCode));
-  (*pJob->userRes.fetchFp)(pRes, pJob->userRes.userParam, atomic_load_32(&pJob->errCode));
+  (*pJob->userRes.fetchFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
   SCH_JOB_DLOG("sch end from fetch cb, code: %s", tstrerror(pJob->errCode));
 
   return TSDB_CODE_SUCCESS;
@@ -956,12 +444,12 @@ int32_t schNotifyUserFetchRes(SSchJob* pJob) {
 
 void schPostJobRes(SSchJob *pJob, SCH_OP_TYPE op) {
   if (SCH_OP_NULL == pJob->opStatus.op) {
-    SCH_JOB_DLOG("job not in any op, no need to post job res, status:%s", jobTaskStatusStr(pJob->status));
+    SCH_JOB_DLOG("job not in any operation, no need to post job res, status:%s", jobTaskStatusStr(pJob->status));
     return;
   }
   
   if (op && pJob->opStatus.op != op) {
-    SCH_JOB_ELOG("job in op %s mis-match with expected %s", schGetOpStr(pJob->opStatus.op), schGetOpStr(op));
+    SCH_JOB_ELOG("job in operation %s mis-match with expected %s", schGetOpStr(pJob->opStatus.op), schGetOpStr(op));
     return;
   }
   
@@ -977,9 +465,6 @@ void schPostJobRes(SSchJob *pJob, SCH_OP_TYPE op) {
 }
 
 int32_t schProcessOnJobFailureImpl(SSchJob *pJob, int32_t status, int32_t errCode) {
-  // if already FAILED, no more processing
-  SCH_ERR_RET(schUpdateJobStatus(pJob, status));
-
   schUpdateJobErrCode(pJob, errCode);
   
   int32_t code = atomic_load_32(&pJob->errCode);
@@ -989,97 +474,49 @@ int32_t schProcessOnJobFailureImpl(SSchJob *pJob, int32_t status, int32_t errCod
 
   schPostJobRes(pJob, 0);
 
-  SCH_RET(code);
+  SCH_RET(TSDB_CODE_SCH_IGNORE_ERROR);
 }
 
 // Note: no more task error processing, handled in function internal
 int32_t schProcessOnJobFailure(SSchJob *pJob, int32_t errCode) {
-  SCH_RET(schProcessOnJobFailureImpl(pJob, JOB_TASK_STATUS_FAILED, errCode));
+  if (TSDB_CODE_SCH_IGNORE_ERROR == errCode) {
+    return TSDB_CODE_SCH_IGNORE_ERROR;
+  }
+
+  schProcessOnJobFailureImpl(pJob, JOB_TASK_STATUS_FAIL, errCode);
+  return TSDB_CODE_SCH_IGNORE_ERROR;
 }
 
 // Note: no more error processing, handled in function internal
 int32_t schProcessOnJobDropped(SSchJob *pJob, int32_t errCode) {
-  SCH_RET(schProcessOnJobFailureImpl(pJob, JOB_TASK_STATUS_DROPPING, errCode));
+  SCH_RET(schProcessOnJobFailureImpl(pJob, JOB_TASK_STATUS_DROP, errCode));
 }
 
-// Note: no more task error processing, handled in function internal
 int32_t schProcessOnJobPartialSuccess(SSchJob *pJob) {
-  int32_t code = 0;
-
-  SCH_ERR_RET(schUpdateJobStatus(pJob, JOB_TASK_STATUS_PARTIAL_SUCCEED));
-
   schPostJobRes(pJob, SCH_OP_EXEC);
 
   return TSDB_CODE_SUCCESS;
-
-_return:
-
-  SCH_RET(schProcessOnJobFailure(pJob, code));
 }
 
 void schProcessOnDataFetched(SSchJob *pJob) {
   schPostJobRes(pJob, SCH_OP_FETCH);
 }
 
-// Note: no more task error processing, handled in function internal
-int32_t schProcessOnTaskFailure(SSchJob *pJob, SSchTask *pTask, int32_t errCode) {
-  int8_t status = 0;
+int32_t schProcessOnExplainDone(SSchJob *pJob, SSchTask *pTask, SRetrieveTableRsp *pRsp) {
+  SCH_TASK_DLOG("got explain rsp, rows:%d, complete:%d", htonl(pRsp->numOfRows), pRsp->completed);
 
-  if (errCode == TSDB_CODE_SCH_TIMEOUT_ERROR) {
-    SCH_LOG_TASK_WAIT_TS(pTask);
-  } else {
-    SCH_LOG_TASK_END_TS(pTask);
-  }
-  
-  if (schJobNeedToStop(pJob, &status)) {
-    SCH_TASK_DLOG("task failed not processed cause of job status, job status:%s", jobTaskStatusStr(status));
-    SCH_RET(atomic_load_32(&pJob->errCode));
-  }
+  atomic_store_32(&pJob->resNumOfRows, htonl(pRsp->numOfRows));
+  atomic_store_ptr(&pJob->resData, pRsp);
 
-  bool    needRetry = false;
-  bool    moved = false;
-  int32_t taskDone = 0;
-  int32_t code = 0;
+  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_SUCC);
 
-  SCH_TASK_DLOG("taskOnFailure, code:%s", tstrerror(errCode));
+  schProcessOnDataFetched(pJob);
 
-  SCH_ERR_JRET(schTaskCheckSetRetry(pJob, pTask, errCode, &needRetry));
-
-  if (!needRetry) {
-    SCH_TASK_ELOG("task failed and no more retry, code:%s", tstrerror(errCode));
-
-    if (SCH_GET_TASK_STATUS(pTask) != JOB_TASK_STATUS_EXECUTING) {
-      SCH_TASK_ELOG("task not in executing list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-      SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-    }
-
-    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_FAILED);
-
-    if (SCH_IS_WAIT_ALL_JOB(pJob)) {
-      SCH_LOCK(SCH_WRITE, &pTask->level->lock);
-      pTask->level->taskFailed++;
-      taskDone = pTask->level->taskSucceed + pTask->level->taskFailed;
-      SCH_UNLOCK(SCH_WRITE, &pTask->level->lock);
-
-      schUpdateJobErrCode(pJob, errCode);
-
-      if (taskDone < pTask->level->taskNum) {
-        SCH_TASK_DLOG("need to wait other tasks, doneNum:%d, allNum:%d", taskDone, pTask->level->taskNum);
-        SCH_RET(errCode);
-      }
-    }
-  } else {
-    SCH_ERR_JRET(schHandleTaskRetry(pJob, pTask));
-
-    return TSDB_CODE_SUCCESS;
-  }
-
-_return:
-
-  SCH_RET(schProcessOnJobFailure(pJob, errCode));
+  return TSDB_CODE_SUCCESS;
 }
 
-int32_t schLaunchNextLevelTasks(SSchJob *pJob, SSchTask *pTask) {
+
+int32_t schLaunchJobLowerLevel(SSchJob *pJob, SSchTask *pTask) {
   if (!SCH_IS_QUERY_JOB(pJob)) {
     return TSDB_CODE_SUCCESS;
   }
@@ -1104,217 +541,6 @@ int32_t schLaunchNextLevelTasks(SSchJob *pJob, SSchTask *pTask) {
   return TSDB_CODE_SUCCESS;
 }
 
-
-// Note: no more task error processing, handled in function internal
-int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
-  bool    moved = false;
-  int32_t code = 0;
-
-  SCH_TASK_DLOG("taskOnSuccess, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-
-  SCH_LOG_TASK_END_TS(pTask);
-
-  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_PARTIAL_SUCCEED);
-
-  SCH_ERR_JRET(schRecordTaskSucceedNode(pJob, pTask));
-
-  SCH_ERR_JRET(schLaunchTasksInFlowCtrlList(pJob, pTask));
-
-  int32_t parentNum = pTask->parents ? (int32_t)taosArrayGetSize(pTask->parents) : 0;
-  if (parentNum == 0) {
-    int32_t taskDone = 0;
-    if (SCH_IS_WAIT_ALL_JOB(pJob)) {
-      SCH_LOCK(SCH_WRITE, &pTask->level->lock);
-      pTask->level->taskSucceed++;
-      taskDone = pTask->level->taskSucceed + pTask->level->taskFailed;
-      SCH_UNLOCK(SCH_WRITE, &pTask->level->lock);
-
-      if (taskDone < pTask->level->taskNum) {
-        SCH_TASK_DLOG("wait all tasks, done:%d, all:%d", taskDone, pTask->level->taskNum);
-        return TSDB_CODE_SUCCESS;
-      } else if (taskDone > pTask->level->taskNum) {
-        SCH_TASK_ELOG("taskDone number invalid, done:%d, total:%d", taskDone, pTask->level->taskNum);
-      }
-
-      if (pTask->level->taskFailed > 0) {
-        SCH_RET(schProcessOnJobFailure(pJob, 0));
-      } else {
-        SCH_RET(schProcessOnJobPartialSuccess(pJob));
-      }
-    } else {
-      pJob->resNode = pTask->succeedAddr;
-    }
-
-    pJob->fetchTask = pTask;
-
-    SCH_RET(schProcessOnJobPartialSuccess(pJob));
-  }
-
-  /*
-    if (SCH_IS_DATA_SRC_TASK(task) && job->dataSrcEps.numOfEps < SCH_MAX_CANDIDATE_EP_NUM) {
-      strncpy(job->dataSrcEps.fqdn[job->dataSrcEps.numOfEps], task->execAddr.fqdn, sizeof(task->execAddr.fqdn));
-      job->dataSrcEps.port[job->dataSrcEps.numOfEps] = task->execAddr.port;
-
-      ++job->dataSrcEps.numOfEps;
-    }
-  */
-
-  for (int32_t i = 0; i < parentNum; ++i) {
-    SSchTask *parent = *(SSchTask **)taosArrayGet(pTask->parents, i);
-    int32_t   readyNum = atomic_add_fetch_32(&parent->childReady, 1);
-
-    SCH_LOCK(SCH_WRITE, &parent->lock);
-    SDownstreamSourceNode source = {.type = QUERY_NODE_DOWNSTREAM_SOURCE,
-                                    .taskId = pTask->taskId,
-                                    .schedId = schMgmt.sId,
-                                    .execId = pTask->execId,
-                                    .addr = pTask->succeedAddr};
-    qSetSubplanExecutionNode(parent->plan, pTask->plan->id.groupId, &source);
-    SCH_UNLOCK(SCH_WRITE, &parent->lock);
-
-    if (SCH_TASK_READY_FOR_LAUNCH(readyNum, parent)) {
-      SCH_TASK_DLOG("all %d children task done, start to launch parent task 0x%" PRIx64, readyNum, parent->taskId);
-      SCH_ERR_RET(schLaunchTask(pJob, parent));
-    }
-  }
-
-  SCH_ERR_RET(schLaunchNextLevelTasks(pJob, pTask));
-
-  return TSDB_CODE_SUCCESS;
-
-_return:
-
-  SCH_RET(schProcessOnJobFailure(pJob, code));
-}
-
-// Note: no more error processing, handled in function internal
-int32_t schFetchFromRemote(SSchJob *pJob) {
-  int32_t code = 0;
-
-  void *resData = atomic_load_ptr(&pJob->resData);
-  if (resData) {
-    SCH_JOB_DLOG("res already fetched, res:%p", resData);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SCH_ERR_JRET(schBuildAndSendMsg(pJob, pJob->fetchTask, &pJob->resNode, TDMT_SCH_FETCH));
-
-  return TSDB_CODE_SUCCESS;
-
-_return:
-
-  SCH_RET(schProcessOnTaskFailure(pJob, pJob->fetchTask, code));
-}
-
-int32_t schProcessOnExplainDone(SSchJob *pJob, SSchTask *pTask, SRetrieveTableRsp *pRsp) {
-  SCH_TASK_DLOG("got explain rsp, rows:%d, complete:%d", htonl(pRsp->numOfRows), pRsp->completed);
-
-  atomic_store_32(&pJob->resNumOfRows, htonl(pRsp->numOfRows));
-  atomic_store_ptr(&pJob->resData, pRsp);
-
-  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_SUCCEED);
-
-  schProcessOnDataFetched(pJob);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-void schDropTaskOnExecNode(SSchJob *pJob, SSchTask *pTask) {
-  if (NULL == pTask->execNodes) {
-    SCH_TASK_DLOG("no exec address, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-    return;
-  }
-
-  int32_t size = (int32_t)taosHashGetSize(pTask->execNodes);
-
-  if (size <= 0) {
-    SCH_TASK_DLOG("task has no execNodes, no need to drop it, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
-    return;
-  }
-
-  SSchNodeInfo *nodeInfo = taosHashIterate(pTask->execNodes, NULL);
-  while (nodeInfo) {
-    SCH_SET_TASK_HANDLE(pTask, nodeInfo->handle);
-
-    schBuildAndSendMsg(pJob, pTask, &nodeInfo->addr, TDMT_SCH_DROP_TASK);
-
-    nodeInfo = taosHashIterate(pTask->execNodes, nodeInfo);
-  }
-
-  SCH_TASK_DLOG("task has been dropped on %d exec nodes", size);
-}
-
-
-int32_t schRescheduleTask(SSchJob *pJob, SSchTask *pTask) {
-  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SCH_LOCK_TASK(pTask);
-  if (SCH_TASK_TIMEOUT(pTask) && JOB_TASK_STATUS_EXECUTING == pTask->status && 
-      pJob->fetchTask != pTask && taosArrayGetSize(pTask->candidateAddrs) > 1) {
-    SCH_TASK_DLOG("task execId %d will be rescheduled now", pTask->execId);
-    schDropTaskOnExecNode(pJob, pTask);
-    taosHashClear(pTask->execNodes);
-    schProcessOnTaskFailure(pJob, pTask, TSDB_CODE_SCH_TIMEOUT_ERROR);
-  }
-  SCH_UNLOCK_TASK(pTask);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t schProcessOnTaskStatusRsp(SQueryNodeEpId* pEpId, SArray* pStatusList) {
-  int32_t taskNum = (int32_t)taosArrayGetSize(pStatusList);
-  SSchTask *pTask = NULL;
-
-  qDebug("%d task status in hb rsp from nodeId:%d, fqdn:%s, port:%d", taskNum, pEpId->nodeId, pEpId->ep.fqdn, pEpId->ep.port);
-
-  for (int32_t i = 0; i < taskNum; ++i) {
-    STaskStatus *taskStatus = taosArrayGet(pStatusList, i);
-
-    qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d task status in server: %s", 
-      taskStatus->queryId, taskStatus->taskId, taskStatus->execId, jobTaskStatusStr(taskStatus->status));
-
-    SSchJob *pJob = schAcquireJob(taskStatus->refId);
-    if (NULL == pJob) {
-      qWarn("job not found, refId:0x%" PRIx64 ",QID:0x%" PRIx64 ",TID:0x%" PRIx64, taskStatus->refId,
-            taskStatus->queryId, taskStatus->taskId);
-      // TODO DROP TASK FROM SERVER!!!!
-      continue;
-    }
-
-    pTask = NULL;
-    schGetTaskInJob(pJob, taskStatus->taskId, &pTask);
-    if (NULL == pTask) {
-      // TODO DROP TASK FROM SERVER!!!!
-      schReleaseJob(taskStatus->refId);
-      continue;
-    }
-
-    if (taskStatus->execId != pTask->execId) {
-      // TODO DROP TASK FROM SERVER!!!!
-      SCH_TASK_DLOG("EID %d in hb rsp mis-match", taskStatus->execId);
-      schReleaseJob(taskStatus->refId);
-      continue;      
-    }
-    
-    if (taskStatus->status == JOB_TASK_STATUS_FAILED) {
-      // RECORD AND HANDLE ERROR!!!!
-      schReleaseJob(taskStatus->refId);
-      continue;
-    }
-
-    if (taskStatus->status == JOB_TASK_STATUS_NOT_START) {
-      schRescheduleTask(pJob, pTask);
-    }
-
-    schReleaseJob(taskStatus->refId);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
 int32_t schSaveJobQueryRes(SSchJob *pJob, SQueryTableRsp *rsp) {
   if (rsp->tbFName[0]) {
     if (NULL == pJob->execRes.res) {
@@ -1336,22 +562,6 @@ int32_t schSaveJobQueryRes(SSchJob *pJob, SQueryTableRsp *rsp) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schGetTaskFromList(SHashObj *pTaskList, uint64_t taskId, SSchTask **pTask) {
-  int32_t s = taosHashGetSize(pTaskList);
-  if (s <= 0) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SSchTask **task = taosHashGet(pTaskList, &taskId, sizeof(taskId));
-  if (NULL == task || NULL == (*task)) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  *pTask = *task;
-
-  return TSDB_CODE_SUCCESS;
-}
-
 int32_t schGetTaskInJob(SSchJob *pJob, uint64_t taskId, SSchTask **pTask) {
   schGetTaskFromList(pJob->taskList, taskId, pTask);
   if (NULL == *pTask) {
@@ -1362,125 +572,26 @@ int32_t schGetTaskInJob(SSchJob *pJob, uint64_t taskId, SSchTask **pTask) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schLaunchTaskImpl(SSchJob *pJob, SSchTask *pTask) {
-  int8_t  status = 0;
-  int32_t code = 0;
-
-  atomic_add_fetch_32(&pTask->level->taskLaunchedNum, 1);
-  pTask->execId++;
-
-  SCH_TASK_DLOG("start to launch task's %dth exec", pTask->execId);
-
-  SCH_LOG_TASK_START_TS(pTask);
-
-  if (schJobNeedToStop(pJob, &status)) {
-    SCH_TASK_DLOG("no need to launch task cause of job status, job status:%s", jobTaskStatusStr(status));
-
-    SCH_RET(atomic_load_32(&pJob->errCode));
-  }
-
-  // NOTE: race condition: the task should be put into the hash table before send msg to server
-  if (SCH_GET_TASK_STATUS(pTask) != JOB_TASK_STATUS_EXECUTING) {
-    SCH_ERR_RET(schPushTaskToExecList(pJob, pTask));
-    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_EXECUTING);
-  }
-
-  SSubplan *plan = pTask->plan;
-
-  if (NULL == pTask->msg) {  // TODO add more detailed reason for failure
-    code = qSubPlanToString(plan, &pTask->msg, &pTask->msgLen);
-    if (TSDB_CODE_SUCCESS != code) {
-      SCH_TASK_ELOG("failed to create physical plan, code:%s, msg:%p, len:%d", tstrerror(code), pTask->msg,
-                    pTask->msgLen);
-      SCH_ERR_RET(code);
-    } else {
-      SCH_TASK_DLOGL("physical plan len:%d, %s", pTask->msgLen, pTask->msg);
-    }
-  }
-
-  SCH_ERR_RET(schSetTaskCandidateAddrs(pJob, pTask));
-
-  if (SCH_IS_QUERY_JOB(pJob)) {
-    SCH_ERR_RET(schEnsureHbConnection(pJob, pTask));
-  }
-
-  SCH_ERR_RET(schBuildAndSendMsg(pJob, pTask, NULL, plan->msgType));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-// Note: no more error processing, handled in function internal
-int32_t schLaunchTask(SSchJob *pJob, SSchTask *pTask) {
-  bool    enough = false;
-  int32_t code = 0;
-
-  SCH_SET_TASK_HANDLE(pTask, NULL);
-
-  if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
-    SCH_ERR_JRET(schCheckIncTaskFlowQuota(pJob, pTask, &enough));
-
-    if (enough) {
-      SCH_ERR_JRET(schLaunchTaskImpl(pJob, pTask));
-    }
-  } else {
-    SCH_ERR_JRET(schLaunchTaskImpl(pJob, pTask));
-  }
-
-  return TSDB_CODE_SUCCESS;
-
-_return:
-
-  SCH_RET(schProcessOnTaskFailure(pJob, pTask, code));
-}
-
-int32_t schLaunchLevelTasks(SSchJob *pJob, SSchLevel *level) {
-  for (int32_t i = 0; i < level->taskNum; ++i) {
-    SSchTask *pTask = taosArrayGet(level->subTasks, i);
-
-    SCH_ERR_RET(schLaunchTask(pJob, pTask));
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
 
 int32_t schLaunchJob(SSchJob *pJob) {
-  SSchLevel *level = taosArrayGet(pJob->levels, pJob->levelIdx);
-
-  SCH_ERR_RET(schChkJobNeedFlowCtrl(pJob, level));
-
-  SCH_ERR_RET(schLaunchLevelTasks(pJob, level));
+  if (EXPLAIN_MODE_STATIC == pJob->attr.explainMode) {
+    SCH_ERR_RET(qExecStaticExplain(pJob->pDag, (SRetrieveTableRsp **)&pJob->resData));
+    SCH_ERR_RET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_PART_SUCC, NULL));
+  } else {
+    SSchLevel *level = taosArrayGet(pJob->levels, pJob->levelIdx);
+    SCH_ERR_RET(schLaunchLevelTasks(pJob, level));
+  }
 
   return TSDB_CODE_SUCCESS;
 }
 
 
-void schDropTaskInHashList(SSchJob *pJob, SHashObj *list) {
-  if (!SCH_IS_NEED_DROP_JOB(pJob)) {
-    return;
-  }
-
-  void *pIter = taosHashIterate(list, NULL);
-  while (pIter) {
-    SSchTask *pTask = *(SSchTask **)pIter;
-
-    schDropTaskOnExecNode(pJob, pTask);
-
-    pIter = taosHashIterate(list, pIter);
-  }
-}
-
 void schDropJobAllTasks(SSchJob *pJob) {
   schDropTaskInHashList(pJob, pJob->execTasks);
 //  schDropTaskInHashList(pJob, pJob->succTasks);
 //  schDropTaskInHashList(pJob, pJob->failTasks);
 }
 
-int32_t schCancelJob(SSchJob *pJob) {
-  // TODO
-  return TSDB_CODE_SUCCESS;
-  // TODO MOVE ALL TASKS FROM EXEC LIST TO FAIL LIST
-}
-
 void schFreeJobImpl(void *job) {
   if (NULL == job) {
     return;
@@ -1492,10 +603,6 @@ void schFreeJobImpl(void *job) {
 
   qDebug("QID:0x%" PRIx64 " begin to free sch job, refId:0x%" PRIx64 ", pointer:%p", queryId, refId, pJob);
 
-  if (pJob->status == JOB_TASK_STATUS_EXECUTING) {
-    schCancelJob(pJob);
-  }
-
   schDropJobAllTasks(pJob);
 
   int32_t numOfLevels = taosArrayGetSize(pJob->levels);
@@ -1528,7 +635,7 @@ void schFreeJobImpl(void *job) {
 
   qDestroyQueryPlan(pJob->pDag);
 
-  taosMemoryFreeClear(pJob->userRes.queryRes);
+  taosMemoryFreeClear(pJob->userRes.execRes);
   taosMemoryFreeClear(pJob->resData);
   taosMemoryFree(pJob);
 
@@ -1540,228 +647,259 @@ void schFreeJobImpl(void *job) {
   qDebug("QID:0x%" PRIx64 " sch job freed, refId:0x%" PRIx64 ", pointer:%p", queryId, refId, pJob);
 }
 
-int32_t schLaunchStaticExplainJob(SSchedulerReq *pReq, SSchJob *pJob, bool sync) {
-  qDebug("QID:0x%" PRIx64 " job started", pReq->pDag->queryId);
-
+int32_t schJobFetchRows(SSchJob *pJob) {
   int32_t  code = 0;
-/*  
+
+  if (!(pJob->attr.explainMode == EXPLAIN_MODE_STATIC)) {
+    SCH_ERR_RET(schLaunchFetchTask(pJob));
+    
+    if (pJob->opStatus.syncReq) {
+      SCH_JOB_DLOG("sync wait for rsp now, job status:%s", SCH_GET_JOB_STATUS_STR(pJob));
+      tsem_wait(&pJob->rspSem);
+      SCH_RET(schDumpJobFetchRes(pJob, pJob->userRes.fetchRes));  
+    }
+  } else {
+    if (pJob->opStatus.syncReq) {
+      SCH_RET(schDumpJobFetchRes(pJob, pJob->userRes.fetchRes));  
+    } else {
+      schPostJobRes(pJob, SCH_OP_FETCH);
+    }
+  }
+
+  SCH_RET(code);
+}
+
+int32_t schInitJob(int64_t *pJobId, SSchedulerReq *pReq) {
+  int32_t  code = 0;
+  int64_t  refId = -1;
   SSchJob *pJob = taosMemoryCalloc(1, sizeof(SSchJob));
   if (NULL == pJob) {
     qError("QID:0x%" PRIx64 " calloc %d failed", pReq->pDag->queryId, (int32_t)sizeof(SSchJob));
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    pReq->fp(NULL, pReq->cbParam, code);
-    SCH_ERR_RET(code);
+    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  pJob->sql = pReq->sql;
-  pJob->reqKilled = pReq->reqKilled;
-  pJob->pDag = pReq->pDag;
-  pJob->attr.queryJob = true;
   pJob->attr.explainMode = pReq->pDag->explainInfo.mode;
-  pJob->queryId = pReq->pDag->queryId;
-  pJob->userRes.execFp = pReq->fp;
-  pJob->userRes.userParam = pReq->cbParam;
-  
-  schUpdateJobStatus(pJob, JOB_TASK_STATUS_NOT_START);
+  pJob->conn = *pReq->pConn;
+  pJob->sql = pReq->sql;
+  pJob->pDag = pReq->pDag;
+  pJob->chkKillFp = pReq->chkKillFp;
+  pJob->chkKillParam = pReq->chkKillParam;
+  pJob->userRes.execFp = pReq->execFp;
+  pJob->userRes.cbParam = pReq->cbParam;
 
-  code = schBeginOperation(pJob, SCH_OP_EXEC, sync);
-  if (code) {
-    pReq->fp(NULL, pReq->cbParam, code);
-    schFreeJobImpl(pJob);
-    SCH_ERR_RET(code);
+  if (pReq->pNodeList == NULL || taosArrayGetSize(pReq->pNodeList) <= 0) {
+    qDebug("QID:0x%" PRIx64 " input exec nodeList is empty", pReq->pDag->queryId);
+  } else {
+    pJob->nodeList = taosArrayDup(pReq->pNodeList);
+  }
+  
+  pJob->taskList =
+      taosHashInit(pReq->pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
+  if (NULL == pJob->taskList) {
+    SCH_JOB_ELOG("taosHashInit %d taskList failed", pReq->pDag->numOfSubplans);
+    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
-*/
 
-  SCH_ERR_JRET(qExecStaticExplain(pReq->pDag, (SRetrieveTableRsp **)&pJob->resData));
+  SCH_ERR_JRET(schValidateAndBuildJob(pReq->pDag, pJob));
 
-/*
-  int64_t refId = taosAddRef(schMgmt.jobRef, pJob);
-  if (refId < 0) {
+  if (SCH_IS_EXPLAIN_JOB(pJob)) {
+    SCH_ERR_JRET(qExecExplainBegin(pReq->pDag, &pJob->explainCtx, pReq->startTs));
+  }
+
+  pJob->execTasks =
+      taosHashInit(pReq->pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
+  if (NULL == pJob->execTasks) {
+    SCH_JOB_ELOG("taosHashInit %d execTasks failed", pReq->pDag->numOfSubplans);
+    SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  tsem_init(&pJob->rspSem, 0, 0);
+
+  pJob->refId = taosAddRef(schMgmt.jobRef, pJob);
+  if (pJob->refId < 0) {
     SCH_JOB_ELOG("taosAddRef job failed, error:%s", tstrerror(terrno));
     SCH_ERR_JRET(terrno);
   }
 
-  if (NULL == schAcquireJob(refId)) {
-    SCH_JOB_ELOG("schAcquireJob job failed, refId:0x%" PRIx64, refId);
-    SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
+  atomic_add_fetch_32(&schMgmt.jobNum, 1);
 
-  pJob->refId = refId;
+  *pJobId = pJob->refId;
 
-  SCH_JOB_DLOG("job refId:0x%" PRIx64, pJob->refId);
-*/
-
-  pJob->status = JOB_TASK_STATUS_PARTIAL_SUCCEED;
-  
-  SCH_JOB_DLOG("job exec done, job status:%s", SCH_GET_JOB_STATUS_STR(pJob));
-  
-  if (!sync) {
-    schPostJobRes(pJob, SCH_OP_EXEC);
-  } else {
-    schEndOperation(pJob);
-  }
-
-//  schReleaseJob(pJob->refId);
-
-  SCH_RET(code);
-
-_return:
-
-  schEndOperation(pJob);
-  if (!sync) {
-    pReq->execFp(NULL, pReq->execParam, code);
-  }
-  
-  schFreeJobImpl(pJob);
-  
-  SCH_RET(code);
-}
-
-int32_t schFetchRows(SSchJob *pJob) {
-  int32_t  code = 0;
-
-  if (!(pJob->attr.explainMode == EXPLAIN_MODE_STATIC)) {
-    SCH_ERR_JRET(schFetchFromRemote(pJob));
-    tsem_wait(&pJob->rspSem);
-  }
-
-  SCH_ERR_JRET(schSetJobFetchRes(pJob, pJob->userRes.fetchRes));
-
-_return:
-
-  schEndOperation(pJob);
-
-  SCH_RET(code);
-}
-
-int32_t schAsyncFetchRows(SSchJob *pJob) {
-  int32_t  code = 0;
-
-  if (pJob->attr.explainMode == EXPLAIN_MODE_STATIC) {
-    schPostJobRes(pJob, SCH_OP_FETCH);
-    return TSDB_CODE_SUCCESS;
-  }
-  
-  SCH_ERR_RET(schFetchFromRemote(pJob));
+  SCH_JOB_DLOG("job refId:0x%" PRIx64" created", pJob->refId);
 
   return TSDB_CODE_SUCCESS;
+
+_return:
+
+  if (NULL == pJob) {
+    qDestroyQueryPlan(pReq->pDag);
+  } else if (pJob->refId < 0) {
+    schFreeJobImpl(pJob);
+  } else {
+    taosRemoveRef(schMgmt.jobRef, pJob->refId);
+  }
+  
+  SCH_RET(code);
 }
 
-
-int32_t schExecJobImpl(SSchedulerReq *pReq, SSchJob *pJob, bool sync) {
-  int32_t  code = 0;
-
+int32_t schExecJob(SSchJob *pJob, SSchedulerReq *pReq) {
+  int32_t code = 0;
   qDebug("QID:0x%" PRIx64 " sch job refId 0x%"PRIx64 " started", pReq->pDag->queryId, pJob->refId);
 
-  SCH_ERR_JRET(schBeginOperation(pJob, SCH_OP_EXEC, sync));
-
-  if (EXPLAIN_MODE_STATIC == pReq->pDag->explainInfo.mode) {
-    code = schLaunchStaticExplainJob(pReq, pJob, sync);
-  } else {
-    code = schLaunchJob(pJob);
-    if (sync) {
-      SCH_JOB_DLOG("will wait for rsp now, job status:%s", SCH_GET_JOB_STATUS_STR(pJob));
-      tsem_wait(&pJob->rspSem);
-      
-      schEndOperation(pJob);
-    } else if (code) {
-      schPostJobRes(pJob, SCH_OP_EXEC);
-    }
+  SCH_ERR_RET(schLaunchJob(pJob));
+  
+  if (pReq->syncReq) {
+    SCH_JOB_DLOG("sync wait for rsp now, job status:%s", SCH_GET_JOB_STATUS_STR(pJob));
+    tsem_wait(&pJob->rspSem);
   }
 
   SCH_JOB_DLOG("job exec done, job status:%s, jobId:0x%" PRIx64, SCH_GET_JOB_STATUS_STR(pJob), pJob->refId);
   
-  SCH_RET(code);
-
-_return:
-
-  if (!sync) {
-    pReq->execFp(NULL, pReq->execParam, code);
-  }
-  
-  SCH_RET(code);
+  return TSDB_CODE_SUCCESS;
 }
 
-int32_t schDoTaskRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32_t rspCode) {
-  int32_t code = 0;
-  
-  if ((pTask->execId + 1) >= pTask->maxExecTimes) {
-    SCH_TASK_DLOG("task no more retry since reach max try times, execId:%d", pTask->execId);
-    schProcessOnJobFailure(pJob, rspCode);
-    return TSDB_CODE_SUCCESS;
-  }
 
-  SCH_TASK_DLOG("task will be redirected now, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+void schProcessOnOpEnd(SSchJob *pJob, SCH_OP_TYPE type, SSchedulerReq* pReq, int32_t errCode) {
+  int32_t op = 0;
   
-  schDropTaskOnExecNode(pJob, pTask);
-  taosHashClear(pTask->execNodes);
-  SCH_ERR_JRET(schRemoveTaskFromExecList(pJob, pTask));
-  schDeregisterTaskHb(pJob, pTask);
-  atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1);
-  taosMemoryFreeClear(pTask->msg);
-  pTask->msgLen = 0;
-  pTask->lastMsgType = 0;
-  memset(&pTask->succeedAddr, 0, sizeof(pTask->succeedAddr));
-
-  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
-    if (pData) {
-      SCH_ERR_JRET(schUpdateTaskCandidateAddr(pJob, pTask, pData->pEpSet));
-    }
-  
-    if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
-      if (JOB_TASK_STATUS_EXECUTING == SCH_GET_TASK_STATUS(pTask)) {
-        SCH_ERR_JRET(schLaunchTasksInFlowCtrlList(pJob, pTask));
+  switch (type) {
+    case SCH_OP_EXEC:
+      if (pReq && pReq->syncReq) {
+        op = atomic_val_compare_exchange_32(&pJob->opStatus.op, type, SCH_OP_NULL);
+        if (SCH_OP_NULL == op || op != type) {
+          SCH_JOB_ELOG("job not in %s operation, op:%s, status:%s", schGetOpStr(type), schGetOpStr(op), jobTaskStatusStr(pJob->status));
+        }
+        schDumpJobExecRes(pJob, pReq->pExecRes);
       }
-    }    
+      break;
+    case SCH_OP_FETCH:
+      if (pReq && pReq->syncReq) {
+        op = atomic_val_compare_exchange_32(&pJob->opStatus.op, type, SCH_OP_NULL);
+        if (SCH_OP_NULL == op || op != type) {
+          SCH_JOB_ELOG("job not in %s operation, op:%s, status:%s", schGetOpStr(type), schGetOpStr(op), jobTaskStatusStr(pJob->status));
+        }
+      }
+      break;
+    case SCH_OP_GET_STATUS:
+      errCode = TSDB_CODE_SUCCESS;
+      break;
+    default:
+      break;
+  }
 
-    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_NOT_START);
+  if (errCode) {
+    schSwitchJobStatus(pJob, JOB_TASK_STATUS_FAIL, (void*)&errCode);
+  }
+
+  SCH_JOB_DLOG("job end %s operation with code %s", schGetOpStr(type), tstrerror(errCode));
+}
+
+int32_t schProcessOnOpBegin(SSchJob* pJob, SCH_OP_TYPE type, SSchedulerReq* pReq) {
+  int32_t code = 0;
+  int8_t status = 0;
+
+  if (schJobNeedToStop(pJob, &status)) {
+    SCH_JOB_ELOG("abort op %s cause of job need to stop, status:%s", schGetOpStr(type), jobTaskStatusStr(status));
+    SCH_ERR_RET(TSDB_CODE_SCH_IGNORE_ERROR);
+  }
+      
+  switch (type) {
+    case SCH_OP_EXEC:
+      if (SCH_OP_NULL != atomic_val_compare_exchange_32(&pJob->opStatus.op, SCH_OP_NULL, type)) {
+        SCH_JOB_ELOG("job already in %s operation", schGetOpStr(pJob->opStatus.op));
+        SCH_ERR_RET(TSDB_CODE_TSC_APP_ERROR);
+      }
+      
+      SCH_JOB_DLOG("job start %s operation", schGetOpStr(pJob->opStatus.op));
+      
+      pJob->opStatus.syncReq = pReq->syncReq;
+      break;
+    case SCH_OP_FETCH:
+      if (SCH_OP_NULL != atomic_val_compare_exchange_32(&pJob->opStatus.op, SCH_OP_NULL, type)) {
+        SCH_JOB_ELOG("job already in %s operation", schGetOpStr(pJob->opStatus.op));
+        SCH_ERR_RET(TSDB_CODE_TSC_APP_ERROR);
+      }
+      
+      SCH_JOB_DLOG("job start %s operation", schGetOpStr(pJob->opStatus.op));
+      
+      pJob->opStatus.syncReq = pReq->syncReq;
     
-    SCH_ERR_JRET(schLaunchTask(pJob, pTask));
+      if (!SCH_JOB_NEED_FETCH(pJob)) {
+        SCH_JOB_ELOG("no need to fetch data, status:%s", SCH_GET_JOB_STATUS_STR(pJob));
+        SCH_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
+      }
 
-    return TSDB_CODE_SUCCESS;
+      if (status != JOB_TASK_STATUS_PART_SUCC) {
+        SCH_JOB_ELOG("job status error for fetch, status:%s", jobTaskStatusStr(status));
+        SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+      }
+      
+      pJob->userRes.fetchRes = pReq->pFetchRes;
+      pJob->userRes.fetchFp = pReq->fetchFp;
+      pJob->userRes.cbParam = pReq->cbParam;
+      
+      break;
+    case SCH_OP_GET_STATUS:
+      if (pJob->status < JOB_TASK_STATUS_INIT || pJob->levelNum <= 0 || NULL == pJob->levels) {
+        qDebug("job not initialized or not executable job, refId:0x%" PRIx64, pJob->refId);
+        SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+      }
+      break;
+    default:
+      SCH_JOB_ELOG("unknown operation type %d", type);
+      SCH_ERR_RET(TSDB_CODE_TSC_APP_ERROR);
   }
 
+  return TSDB_CODE_SUCCESS;
+}
 
-  // merge plan
-  
-  pTask->childReady = 0;
-  
-  qClearSubplanExecutionNode(pTask->plan);
-
-  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_NOT_START);
-  
-  int32_t childrenNum = taosArrayGetSize(pTask->children);
-  for (int32_t i = 0; i < childrenNum; ++i) {
-    SSchTask* pChild = taosArrayGetP(pTask->children, i);
-    SCH_LOCK_TASK(pChild);
-    schDoTaskRedirect(pJob, pChild, NULL, rspCode);
-    SCH_UNLOCK_TASK(pChild);
+void schProcessOnCbEnd(SSchJob *pJob, SSchTask *pTask, int32_t errCode) {
+  if (pTask) {
+    SCH_UNLOCK_TASK(pTask);
   }
 
+  if (errCode) {
+    schSwitchJobStatus(pJob, JOB_TASK_STATUS_FAIL, (void*)&errCode);
+  }
+  
+  if (pJob) {
+    schReleaseJob(pJob->refId);
+  }
+}
+
+int32_t schProcessOnCbBegin(SSchJob** job, SSchTask** task, uint64_t qId, int64_t rId, uint64_t tId) {
+  int32_t code = 0;
+  int8_t status = 0;
+
+  SSchTask *pTask = NULL;
+  SSchJob *pJob = schAcquireJob(rId);
+  if (NULL == pJob) {
+    qWarn("QID:0x%" PRIx64 ",TID:0x%" PRIx64 "job no exist, may be dropped, refId:0x%" PRIx64, qId, tId, rId);
+    SCH_ERR_RET(TSDB_CODE_QRY_JOB_NOT_EXIST);
+  }
+  
+  if (schJobNeedToStop(pJob, &status)) {
+    SCH_TASK_ELOG("will not do further processing cause of job status %s", jobTaskStatusStr(status));
+    SCH_ERR_JRET(TSDB_CODE_SCH_IGNORE_ERROR);
+  }
+
+  SCH_ERR_JRET(schGetTaskInJob(pJob, tId, &pTask));
+
+  SCH_LOCK_TASK(pTask);
+
+  *job = pJob;
+  *task = pTask;
+
   return TSDB_CODE_SUCCESS;
 
 _return:
 
-  code = schProcessOnTaskFailure(pJob, pTask, code);
-
-  SCH_RET(code);  
-}
-
-int32_t schHandleRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32_t rspCode) {
-  int32_t code = 0;
-
-  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
-    if (NULL == pData->pEpSet) {
-      SCH_TASK_ELOG("no epset updated while got error %s", tstrerror(rspCode));
-      SCH_ERR_JRET(rspCode);
-    }
+  if (pTask) {
+    SCH_UNLOCK_TASK(pTask);
+  }
+  if (pJob) {
+    schReleaseJob(rId);
   }
-
-  SCH_RET(schDoTaskRedirect(pJob, pTask, pData, rspCode));
-
-_return:
-
-  schProcessOnTaskFailure(pJob, pTask, code);
   
   SCH_RET(code);
 }
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index 07b2560824..bf85d09e00 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -16,7 +16,7 @@
 #include "catalog.h"
 #include "command.h"
 #include "query.h"
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "tmsg.h"
 #include "tref.h"
 #include "trpc.h"
@@ -36,7 +36,7 @@ int32_t schValidateReceivedMsgType(SSchJob *pJob, SSchTask *pTask, int32_t msgTy
                       TMSG_INFO(msgType));
       }
 
-      if (taskStatus != JOB_TASK_STATUS_EXECUTING && taskStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED) {
+      if (taskStatus != JOB_TASK_STATUS_EXEC && taskStatus != JOB_TASK_STATUS_PART_SUCC) {
         SCH_TASK_DLOG("rsp msg conflicted with task status, status:%s, rspType:%s", jobTaskStatusStr(taskStatus),
                       TMSG_INFO(msgType));
       }
@@ -50,7 +50,7 @@ int32_t schValidateReceivedMsgType(SSchJob *pJob, SSchTask *pTask, int32_t msgTy
         SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
       }
 
-      if (taskStatus != JOB_TASK_STATUS_EXECUTING && taskStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED) {
+      if (taskStatus != JOB_TASK_STATUS_EXEC && taskStatus != JOB_TASK_STATUS_PART_SUCC) {
         SCH_TASK_ELOG("rsp msg conflicted with task status, status:%s, rspType:%s", jobTaskStatusStr(taskStatus),
                       TMSG_INFO(msgType));
         SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
@@ -76,7 +76,7 @@ int32_t schValidateReceivedMsgType(SSchJob *pJob, SSchTask *pTask, int32_t msgTy
     SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
   }
 
-  if (taskStatus != JOB_TASK_STATUS_EXECUTING && taskStatus != JOB_TASK_STATUS_PARTIAL_SUCCEED) {
+  if (taskStatus != JOB_TASK_STATUS_EXEC && taskStatus != JOB_TASK_STATUS_PART_SUCC) {
     SCH_TASK_ELOG("rsp msg conflicted with task status, status:%s, rspType:%s", jobTaskStatusStr(taskStatus),
                   TMSG_INFO(msgType));
     SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
@@ -88,9 +88,21 @@ int32_t schValidateReceivedMsgType(SSchJob *pJob, SSchTask *pTask, int32_t msgTy
 }
 
 // Note: no more task error processing, handled in function internal
-int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, char *msg, int32_t msgSize,
-                             int32_t rspCode) {
+int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDataBuf *pMsg, int32_t rspCode) {
   int32_t code = 0;
+  char *msg = pMsg->pData;
+  int32_t msgSize = pMsg->len;
+  int32_t msgType = pMsg->msgType;
+
+  bool dropExecNode = (msgType == TDMT_SCH_LINK_BROKEN || SCH_NETWORK_ERR(rspCode));
+  SCH_ERR_JRET(schUpdateTaskHandle(pJob, pTask, dropExecNode, pMsg->handle, execId));
+
+  SCH_ERR_JRET(schValidateReceivedMsgType(pJob, pTask, msgType));
+
+  int32_t reqType = IsReq(pMsg) ? pMsg->msgType : (pMsg->msgType - 1);
+  if (SCH_NEED_REDIRECT(reqType, rspCode, pMsg->len)) {
+    SCH_RET(schHandleRedirect(pJob, pTask, (SDataBuf *)pMsg, rspCode));
+  }
 
   switch (msgType) {
     case TDMT_VND_COMMIT_RSP: {
@@ -313,7 +325,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
           return TSDB_CODE_SUCCESS;
         }
 
-        SCH_ERR_JRET(schFetchFromRemote(pJob));
+        SCH_ERR_JRET(schLaunchFetchTask(pJob));
 
         taosMemoryFreeClear(msg);
 
@@ -330,7 +342,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
       atomic_add_fetch_32(&pJob->resNumOfRows, htonl(rsp->numOfRows));
 
       if (rsp->completed) {
-        SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_SUCCEED);
+        SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_SUCC);
       }
 
       SCH_TASK_DLOG("got fetch rsp, rows:%d, complete:%d", htonl(rsp->numOfRows), rsp->completed);
@@ -366,65 +378,24 @@ _return:
 
 int32_t schHandleCallback(void *param, SDataBuf *pMsg, int32_t rspCode) {
   int32_t                code = 0;
-  int32_t                msgType = pMsg->msgType;
   SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
   SSchTask              *pTask = NULL;
+  SSchJob               *pJob = NULL;
 
-  SSchJob *pJob = schAcquireJob(pParam->refId);
-  if (NULL == pJob) {
-    qWarn("QID:0x%" PRIx64 ",TID:0x%" PRIx64 "taosAcquireRef job failed, may be dropped, refId:0x%" PRIx64,
-          pParam->queryId, pParam->taskId, pParam->refId);
-    SCH_ERR_JRET(TSDB_CODE_QRY_JOB_FREED);
-  }
+  qDebug("begin to handle rsp msg, type:%s, handle:%p, code:%s", TMSG_INFO(pMsg->msgType), pMsg->handle, tstrerror(rspCode));
 
-  SCH_ERR_JRET(schGetTaskInJob(pJob, pParam->taskId, &pTask));
+  SCH_ERR_RET(schProcessOnCbBegin(&pJob, &pTask, pParam->queryId, pParam->refId, pParam->taskId));
 
-  SCH_LOCK_TASK(pTask);
-
-  SCH_TASK_DLOG("rsp msg received, type:%s, handle:%p, code:%s", TMSG_INFO(msgType), pMsg->handle, tstrerror(rspCode));
-
-  if (pParam->execId != pTask->execId) {
-    SCH_TASK_DLOG("execId %d mis-match current execId %d", pParam->execId, pTask->execId);
-    goto _return;
-  }
-
-  bool dropExecNode = (msgType == TDMT_SCH_LINK_BROKEN || SCH_NETWORK_ERR(rspCode));
-  SCH_ERR_JRET(schUpdateTaskHandle(pJob, pTask, dropExecNode, pMsg->handle, pParam->execId));
-
-  int8_t status = 0;
-  if (schJobNeedToStop(pJob, &status)) {
-    SCH_TASK_ELOG("rsp will not be processed cause of job status %s, rspCode:0x%x", jobTaskStatusStr(status), rspCode);
-    code = atomic_load_32(&pJob->errCode);
-    goto _return;
-  }
-
-  SCH_ERR_JRET(schValidateReceivedMsgType(pJob, pTask, msgType));
-
-  int32_t reqType = IsReq(pMsg) ? pMsg->msgType : (pMsg->msgType - 1);
-  if (SCH_NEED_REDIRECT(reqType, rspCode, pMsg->len)) {
-    code = schHandleRedirect(pJob, pTask, (SDataBuf *)pMsg, rspCode);
-    goto _return;
-  }
-  
-  schHandleResponseMsg(pJob, pTask, msgType, pMsg->pData, pMsg->len, rspCode);
+  code = schHandleResponseMsg(pJob, pTask, pParam->execId, pMsg, rspCode);
   pMsg->pData = NULL;
 
-_return:
-
-  if (pTask) {
-    if (code) {
-      schProcessOnTaskFailure(pJob, pTask, code);
-    }
-
-    SCH_UNLOCK_TASK(pTask);
-  }
-
-  if (pJob) {
-    schReleaseJob(pParam->refId);
-  }
+  schProcessOnCbEnd(pJob, pTask, code);
 
   taosMemoryFreeClear(pMsg->pData);
   taosMemoryFreeClear(param);
+
+  qDebug("end to handle rsp msg, type:%s, handle:%p, code:%s", TMSG_INFO(pMsg->msgType), pMsg->handle, tstrerror(rspCode));
+
   SCH_RET(code);
 }
 
@@ -459,8 +430,38 @@ int32_t schHandleCommitCallback(void *param, SDataBuf *pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, code);
 }
 
-int32_t schMakeCallbackParam(SSchJob *pJob, SSchTask *pTask, int32_t msgType, bool isHb, SSchTrans *trans,
-                             void **pParam) {
+int32_t schHandleHbCallback(void *param, SDataBuf *pMsg, int32_t code) {
+  SSchedulerHbRsp rsp = {0};
+  SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
+
+  if (code) {
+    qError("hb rsp error:%s", tstrerror(code));
+    SCH_ERR_JRET(code);
+  }
+
+  if (tDeserializeSSchedulerHbRsp(pMsg->pData, pMsg->len, &rsp)) {
+    qError("invalid hb rsp msg, size:%d", pMsg->len);
+    SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+  }
+
+  SSchTrans trans = {0};
+  trans.pTrans = pParam->pTrans;
+  trans.pHandle = pMsg->handle;
+
+  SCH_ERR_JRET(schUpdateHbConnection(&rsp.epId, &trans));
+
+  SCH_ERR_JRET(schProcessOnTaskStatusRsp(&rsp.epId, rsp.taskStatus));
+
+_return:
+
+  tFreeSSchedulerHbRsp(&rsp);
+  taosMemoryFree(param);
+
+  SCH_RET(code);
+}
+
+
+int32_t schMakeCallbackParam(SSchJob *pJob, SSchTask *pTask, int32_t msgType, bool isHb, SSchTrans *trans, void **pParam) {
   if (!isHb) {
     SSchTaskCallbackParam *param = taosMemoryCalloc(1, sizeof(SSchTaskCallbackParam));
     if (NULL == param) {
@@ -703,36 +704,6 @@ _return:
   SCH_RET(code);
 }
 
-int32_t schHandleHbCallback(void *param, SDataBuf *pMsg, int32_t code) {
-  SSchedulerHbRsp        rsp = {0};
-  SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
-
-  if (code) {
-    qError("hb rsp error:%s", tstrerror(code));
-    SCH_ERR_JRET(code);
-  }
-
-  if (tDeserializeSSchedulerHbRsp(pMsg->pData, pMsg->len, &rsp)) {
-    qError("invalid hb rsp msg, size:%d", pMsg->len);
-    SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
-  }
-
-  SSchTrans trans = {0};
-  trans.pTrans = pParam->pTrans;
-  trans.pHandle = pMsg->handle;
-
-  SCH_ERR_JRET(schUpdateHbConnection(&rsp.epId, &trans));
-
-  SCH_ERR_JRET(schProcessOnTaskStatusRsp(&rsp.epId, rsp.taskStatus));
-
-_return:
-
-  tFreeSSchedulerHbRsp(&rsp);
-  taosMemoryFree(param);
-
-  SCH_RET(code);
-}
-
 int32_t schMakeBrokenLinkVal(SSchJob *pJob, SSchTask *pTask, SRpcBrokenlinkVal *brokenVal, bool isHb) {
   int32_t       code = 0;
   int32_t       msgType = TDMT_SCH_LINK_BROKEN;
diff --git a/source/libs/scheduler/src/schStatus.c b/source/libs/scheduler/src/schStatus.c
new file mode 100644
index 0000000000..80137f1872
--- /dev/null
+++ b/source/libs/scheduler/src/schStatus.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalog.h"
+#include "command.h"
+#include "query.h"
+#include "schInt.h"
+#include "tmsg.h"
+#include "tref.h"
+#include "trpc.h"
+
+int32_t schSwitchJobStatus(SSchJob* pJob, int32_t status, void* param) {
+  int32_t code = 0;
+  SCH_ERR_JRET(schUpdateJobStatus(pJob, status));
+
+  switch (status) {
+    case JOB_TASK_STATUS_INIT:
+      break;
+    case JOB_TASK_STATUS_EXEC:
+      SCH_ERR_JRET(schExecJob(pJob, (SSchedulerReq*)param));    
+      break;
+    case JOB_TASK_STATUS_PART_SUCC:
+      SCH_ERR_JRET(schProcessOnJobPartialSuccess(pJob));
+      break;
+    case JOB_TASK_STATUS_SUCC:
+      break;
+    case JOB_TASK_STATUS_FAIL:      
+      SCH_RET(schProcessOnJobFailure(pJob, (param ? *(int32_t*)param : 0)));
+      break;
+    case JOB_TASK_STATUS_DROP:
+      SCH_ERR_JRET(schProcessOnJobDropped(pJob, *(int32_t*)param));
+      
+      if (taosRemoveRef(schMgmt.jobRef, pJob->refId)) {
+        SCH_JOB_ELOG("remove job from job list failed, refId:0x%" PRIx64, pJob->refId);
+      } else {
+        SCH_JOB_DLOG("job removed from jobRef list, refId:0x%" PRIx64, pJob->refId);
+      }
+      break;    
+    default: {
+      SCH_JOB_ELOG("unknown job status %d", status);
+      SCH_RET(TSDB_CODE_SCH_STATUS_ERROR);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  SCH_RET(schProcessOnJobFailure(pJob, code));
+}
+
+int32_t schHandleOpBeginEvent(int64_t jobId, SSchJob** job, SCH_OP_TYPE type, SSchedulerReq* pReq) {
+  SSchJob *pJob = schAcquireJob(jobId);
+  if (NULL == pJob) {
+    qError("Acquire sch job failed, may be dropped, jobId:0x%" PRIx64, jobId);
+    SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+  }
+
+  *job = pJob;
+
+  SCH_RET(schProcessOnOpBegin(pJob, type, pReq));
+}
+
+int32_t schHandleOpEndEvent(SSchJob* pJob, SCH_OP_TYPE type, SSchedulerReq* pReq, int32_t errCode) {
+  int32_t code = errCode;
+  
+  if (NULL == pJob) {
+    SCH_RET(code);
+  }
+  
+  schProcessOnOpEnd(pJob, type, pReq, errCode);
+
+  if (TSDB_CODE_SCH_IGNORE_ERROR == errCode) {
+    code = pJob->errCode;
+  }
+
+  schReleaseJob(pJob->refId);
+
+  return code;
+}
+
+
diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c
new file mode 100644
index 0000000000..e60006d75c
--- /dev/null
+++ b/source/libs/scheduler/src/schTask.c
@@ -0,0 +1,830 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "catalog.h"
+#include "command.h"
+#include "query.h"
+#include "schInt.h"
+#include "tmsg.h"
+#include "tref.h"
+#include "trpc.h"
+
+
+
+void schFreeTask(SSchJob *pJob, SSchTask *pTask) {
+  schDeregisterTaskHb(pJob, pTask);
+  
+  if (pTask->candidateAddrs) {
+    taosArrayDestroy(pTask->candidateAddrs);
+  }
+
+  taosMemoryFreeClear(pTask->msg);
+
+  if (pTask->children) {
+    taosArrayDestroy(pTask->children);
+  }
+
+  if (pTask->parents) {
+    taosArrayDestroy(pTask->parents);
+  }
+
+  if (pTask->execNodes) {
+    taosHashCleanup(pTask->execNodes);
+  }
+}
+
+
+int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel) {
+  pTask->plan = pPlan;
+  pTask->level = pLevel;
+  pTask->execId = -1;
+  pTask->maxExecTimes = SCH_TASK_MAX_EXEC_TIMES;
+  pTask->timeoutUsec = SCH_DEFAULT_TASK_TIMEOUT_USEC;
+  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
+  pTask->taskId = schGenTaskId();
+  pTask->execNodes = taosHashInit(SCH_MAX_CANDIDATE_EP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+  if (NULL == pTask->execNodes) {
+    SCH_TASK_ELOG("taosHashInit %d execNodes failed", SCH_MAX_CANDIDATE_EP_NUM);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schRecordTaskSucceedNode(SSchJob *pJob, SSchTask *pTask) {
+  SQueryNodeAddr *addr = taosArrayGet(pTask->candidateAddrs, pTask->candidateIdx);
+  if (NULL == addr) {
+    SCH_TASK_ELOG("taosArrayGet candidate addr failed, idx:%d, size:%d", pTask->candidateIdx,
+                  (int32_t)taosArrayGetSize(pTask->candidateAddrs));
+    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
+  }
+
+  pTask->succeedAddr = *addr;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schAppendTaskExecNode(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, int32_t execId) {
+  SSchNodeInfo nodeInfo = {.addr = *addr, .handle = NULL};
+
+  if (taosHashPut(pTask->execNodes, &execId, sizeof(execId), &nodeInfo, sizeof(nodeInfo))) {
+    SCH_TASK_ELOG("taosHashPut nodeInfo to execNodes failed, errno:%d", errno);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  SCH_TASK_DLOG("task execNode added, execId:%d", execId);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schDropTaskExecNode(SSchJob *pJob, SSchTask *pTask, void *handle, int32_t execId) {
+  if (NULL == pTask->execNodes) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (taosHashRemove(pTask->execNodes, &execId, sizeof(execId))) {
+    SCH_TASK_ELOG("fail to remove execId %d from execNodeList", execId);
+  } else {
+    SCH_TASK_DLOG("execId %d removed from execNodeList", execId);
+  }
+  
+  if (execId != pTask->execId) {     // ignore it
+    SCH_TASK_DLOG("execId %d is not current execId %d", execId, pTask->execId);
+    SCH_ERR_RET(TSDB_CODE_SCH_IGNORE_ERROR);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schUpdateTaskExecNode(SSchJob *pJob, SSchTask *pTask, void *handle, int32_t execId) {
+  if (taosHashGetSize(pTask->execNodes) <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSchNodeInfo *nodeInfo = taosHashGet(pTask->execNodes, &execId, sizeof(execId));
+  nodeInfo->handle = handle;
+
+  SCH_TASK_DLOG("handle updated to %p for execId %d", handle, execId);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schUpdateTaskHandle(SSchJob *pJob, SSchTask *pTask, bool dropExecNode, void *handle, int32_t execId) {
+  if (dropExecNode) {
+    SCH_RET(schDropTaskExecNode(pJob, pTask, handle, execId));
+  }
+
+  SCH_SET_TASK_HANDLE(pTask, handle);
+
+  schUpdateTaskExecNode(pJob, pTask, handle, execId);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+// Note: no more task error processing, handled in function internal
+int32_t schProcessOnTaskFailure(SSchJob *pJob, SSchTask *pTask, int32_t errCode) {
+  if (TSDB_CODE_SCH_IGNORE_ERROR == errCode) {
+    return TSDB_CODE_SCH_IGNORE_ERROR;
+  }
+  
+  int8_t status = 0;
+  if (schJobNeedToStop(pJob, &status)) {
+    SCH_TASK_DLOG("no more task failure processing cause of job status %s", jobTaskStatusStr(status));
+    SCH_ERR_RET(TSDB_CODE_SCH_IGNORE_ERROR);
+  }
+  
+  if (SCH_GET_TASK_STATUS(pTask) != JOB_TASK_STATUS_EXEC) {
+    SCH_TASK_ELOG("task already not in EXEC status, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+    SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+  }
+
+  if (errCode == TSDB_CODE_SCH_TIMEOUT_ERROR) {
+    SCH_LOG_TASK_WAIT_TS(pTask);
+  } else {
+    SCH_LOG_TASK_END_TS(pTask);
+  }
+
+  bool    needRetry = false;
+  bool    moved = false;
+  int32_t taskDone = 0;
+
+  SCH_TASK_DLOG("taskOnFailure, code:%s", tstrerror(errCode));
+
+  SCH_ERR_RET(schTaskCheckSetRetry(pJob, pTask, errCode, &needRetry));
+
+  if (!needRetry) {
+    SCH_TASK_ELOG("task failed and no more retry, code:%s", tstrerror(errCode));
+
+    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_FAIL);
+
+    if (SCH_JOB_NEED_WAIT(pJob)) {
+      SCH_LOCK(SCH_WRITE, &pTask->level->lock);
+      pTask->level->taskFailed++;
+      taskDone = pTask->level->taskSucceed + pTask->level->taskFailed;
+      SCH_UNLOCK(SCH_WRITE, &pTask->level->lock);
+
+      schUpdateJobErrCode(pJob, errCode);
+
+      if (taskDone < pTask->level->taskNum) {
+        SCH_TASK_DLOG("need to wait other tasks, doneNum:%d, allNum:%d", taskDone, pTask->level->taskNum);
+        SCH_RET(TSDB_CODE_SCH_IGNORE_ERROR);
+      }
+
+      SCH_RET(atomic_load_32(&pJob->errCode));
+    }
+  } else {
+    SCH_ERR_RET(schHandleTaskRetry(pJob, pTask));
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SCH_RET(errCode);
+}
+
+
+
+// Note: no more task error processing, handled in function internal
+int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
+  bool    moved = false;
+  int32_t code = 0;
+
+  SCH_TASK_DLOG("taskOnSuccess, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+
+  SCH_LOG_TASK_END_TS(pTask);
+
+  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_PART_SUCC);
+
+  SCH_ERR_RET(schRecordTaskSucceedNode(pJob, pTask));
+
+  SCH_ERR_RET(schLaunchTasksInFlowCtrlList(pJob, pTask));
+
+  int32_t parentNum = pTask->parents ? (int32_t)taosArrayGetSize(pTask->parents) : 0;
+  if (parentNum == 0) {
+    int32_t taskDone = 0;
+    if (SCH_JOB_NEED_WAIT(pJob)) {
+      SCH_LOCK(SCH_WRITE, &pTask->level->lock);
+      pTask->level->taskSucceed++;
+      taskDone = pTask->level->taskSucceed + pTask->level->taskFailed;
+      SCH_UNLOCK(SCH_WRITE, &pTask->level->lock);
+
+      if (taskDone < pTask->level->taskNum) {
+        SCH_TASK_DLOG("wait all tasks, done:%d, all:%d", taskDone, pTask->level->taskNum);
+        return TSDB_CODE_SUCCESS;
+      } else if (taskDone > pTask->level->taskNum) {
+        SCH_TASK_ELOG("taskDone number invalid, done:%d, total:%d", taskDone, pTask->level->taskNum);
+      }
+
+      if (pTask->level->taskFailed > 0) {
+        SCH_RET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_FAIL, NULL));
+      } else {
+        SCH_RET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_PART_SUCC, NULL));
+      }
+    } else {
+      pJob->resNode = pTask->succeedAddr;
+    }
+
+    pJob->fetchTask = pTask;
+
+    SCH_RET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_PART_SUCC, NULL));
+  }
+
+  /*
+    if (SCH_IS_DATA_SRC_TASK(task) && job->dataSrcEps.numOfEps < SCH_MAX_CANDIDATE_EP_NUM) {
+      strncpy(job->dataSrcEps.fqdn[job->dataSrcEps.numOfEps], task->execAddr.fqdn, sizeof(task->execAddr.fqdn));
+      job->dataSrcEps.port[job->dataSrcEps.numOfEps] = task->execAddr.port;
+
+      ++job->dataSrcEps.numOfEps;
+    }
+  */
+
+  for (int32_t i = 0; i < parentNum; ++i) {
+    SSchTask *parent = *(SSchTask **)taosArrayGet(pTask->parents, i);
+    int32_t   readyNum = atomic_add_fetch_32(&parent->childReady, 1);
+
+    SCH_LOCK(SCH_WRITE, &parent->lock);
+    SDownstreamSourceNode source = {.type = QUERY_NODE_DOWNSTREAM_SOURCE,
+                                    .taskId = pTask->taskId,
+                                    .schedId = schMgmt.sId,
+                                    .execId = pTask->execId,
+                                    .addr = pTask->succeedAddr};
+    qSetSubplanExecutionNode(parent->plan, pTask->plan->id.groupId, &source);
+    SCH_UNLOCK(SCH_WRITE, &parent->lock);
+
+    if (SCH_TASK_READY_FOR_LAUNCH(readyNum, parent)) {
+      SCH_TASK_DLOG("all %d children task done, start to launch parent task 0x%" PRIx64, readyNum, parent->taskId);
+      SCH_ERR_RET(schLaunchTask(pJob, parent));
+    }
+  }
+
+  SCH_ERR_RET(schLaunchJobLowerLevel(pJob, pTask));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schRescheduleTask(SSchJob *pJob, SSchTask *pTask) {
+  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (SCH_TASK_TIMEOUT(pTask) && JOB_TASK_STATUS_EXEC == pTask->status && 
+      pJob->fetchTask != pTask && taosArrayGetSize(pTask->candidateAddrs) > 1) {
+    SCH_TASK_DLOG("task execId %d will be rescheduled now", pTask->execId);
+    schDropTaskOnExecNode(pJob, pTask);
+    taosHashClear(pTask->execNodes);
+    
+    SCH_ERR_RET(schProcessOnTaskFailure(pJob, pTask, TSDB_CODE_SCH_TIMEOUT_ERROR));
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schDoTaskRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32_t rspCode) {
+  int32_t code = 0;
+  
+  if ((pTask->execId + 1) >= pTask->maxExecTimes) {
+    SCH_TASK_DLOG("task no more retry since reach max try times, execId:%d", pTask->execId);
+    schSwitchJobStatus(pJob, JOB_TASK_STATUS_FAIL, (void*)&rspCode);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SCH_TASK_DLOG("task will be redirected now, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+  
+  schDropTaskOnExecNode(pJob, pTask);
+  taosHashClear(pTask->execNodes);
+  SCH_ERR_JRET(schRemoveTaskFromExecList(pJob, pTask));
+  schDeregisterTaskHb(pJob, pTask);
+  atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1);
+  taosMemoryFreeClear(pTask->msg);
+  pTask->msgLen = 0;
+  pTask->lastMsgType = 0;
+  memset(&pTask->succeedAddr, 0, sizeof(pTask->succeedAddr));
+
+  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
+    if (pData) {
+      SCH_ERR_JRET(schUpdateTaskCandidateAddr(pJob, pTask, pData->pEpSet));
+    }
+  
+    if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
+      if (JOB_TASK_STATUS_EXEC == SCH_GET_TASK_STATUS(pTask)) {
+        SCH_ERR_JRET(schLaunchTasksInFlowCtrlList(pJob, pTask));
+      }
+    }    
+
+    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
+    
+    SCH_ERR_JRET(schLaunchTask(pJob, pTask));
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+
+  // merge plan
+  
+  pTask->childReady = 0;
+  
+  qClearSubplanExecutionNode(pTask->plan);
+
+  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
+  
+  int32_t childrenNum = taosArrayGetSize(pTask->children);
+  for (int32_t i = 0; i < childrenNum; ++i) {
+    SSchTask* pChild = taosArrayGetP(pTask->children, i);
+    SCH_LOCK_TASK(pChild);
+    schDoTaskRedirect(pJob, pChild, NULL, rspCode);
+    SCH_UNLOCK_TASK(pChild);
+  }
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  SCH_RET(schProcessOnTaskFailure(pJob, pTask, code));
+}
+
+int32_t schHandleRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32_t rspCode) {
+  int32_t code = 0;
+
+  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
+    if (NULL == pData->pEpSet) {
+      SCH_TASK_ELOG("no epset updated while got error %s", tstrerror(rspCode));
+      SCH_ERR_JRET(rspCode);
+    }
+  }
+
+  SCH_RET(schDoTaskRedirect(pJob, pTask, pData, rspCode));
+
+_return:
+
+  SCH_RET(schProcessOnTaskFailure(pJob, pTask, code));
+}
+
+int32_t schPushTaskToExecList(SSchJob *pJob, SSchTask *pTask) {
+  int32_t code = taosHashPut(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
+  if (0 != code) {
+    if (HASH_NODE_EXIST(code)) {
+      SCH_TASK_ELOG("task already in execTask list, code:%x", code);
+      SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
+    }
+
+    SCH_TASK_ELOG("taosHashPut task to execTask list failed, errno:%d", errno);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  SCH_TASK_DLOG("task added to execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+/*
+int32_t schMoveTaskToSuccList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
+  if (0 != taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId))) {
+    SCH_TASK_WLOG("remove task from execTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+  } else {
+    SCH_TASK_DLOG("task removed from execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
+  }
+
+  int32_t code = taosHashPut(pJob->succTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
+  if (0 != code) {
+    if (HASH_NODE_EXIST(code)) {
+      *moved = true;
+      SCH_TASK_ELOG("task already in succTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+    }
+
+    SCH_TASK_ELOG("taosHashPut task to succTask list failed, errno:%d", errno);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  *moved = true;
+
+  SCH_TASK_DLOG("task moved to succTask list, numOfTasks:%d", taosHashGetSize(pJob->succTasks));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schMoveTaskToFailList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
+  *moved = false;
+
+  if (0 != taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId))) {
+    SCH_TASK_WLOG("remove task from execTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+  }
+
+  int32_t code = taosHashPut(pJob->failTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
+  if (0 != code) {
+    if (HASH_NODE_EXIST(code)) {
+      *moved = true;
+
+      SCH_TASK_WLOG("task already in failTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+    }
+
+    SCH_TASK_ELOG("taosHashPut task to failTask list failed, errno:%d", errno);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  *moved = true;
+
+  SCH_TASK_DLOG("task moved to failTask list, numOfTasks:%d", taosHashGetSize(pJob->failTasks));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schMoveTaskToExecList(SSchJob *pJob, SSchTask *pTask, bool *moved) {
+  if (0 != taosHashRemove(pJob->succTasks, &pTask->taskId, sizeof(pTask->taskId))) {
+    SCH_TASK_WLOG("remove task from succTask list failed, may not exist, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+  }
+
+  int32_t code = taosHashPut(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId), &pTask, POINTER_BYTES);
+  if (0 != code) {
+    if (HASH_NODE_EXIST(code)) {
+      *moved = true;
+
+      SCH_TASK_ELOG("task already in execTask list, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+      SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
+    }
+
+    SCH_TASK_ELOG("taosHashPut task to execTask list failed, errno:%d", errno);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  *moved = true;
+
+  SCH_TASK_DLOG("task moved to execTask list, numOfTasks:%d", taosHashGetSize(pJob->execTasks));
+
+  return TSDB_CODE_SUCCESS;
+}
+*/
+
+int32_t schTaskCheckSetRetry(SSchJob *pJob, SSchTask *pTask, int32_t errCode, bool *needRetry) {
+  if (TSDB_CODE_SCH_TIMEOUT_ERROR == errCode) {
+    pTask->maxExecTimes++;
+    if (pTask->timeoutUsec < SCH_MAX_TASK_TIMEOUT_USEC) {
+      pTask->timeoutUsec *= 2;
+      if (pTask->timeoutUsec > SCH_MAX_TASK_TIMEOUT_USEC) {
+        pTask->timeoutUsec = SCH_MAX_TASK_TIMEOUT_USEC;
+      }
+    }
+  }
+
+  if ((pTask->execId + 1) >= pTask->maxExecTimes) {
+    *needRetry = false;
+    SCH_TASK_DLOG("task no more retry since reach max try times, execId:%d", pTask->execId);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (!SCH_NEED_RETRY(pTask->lastMsgType, errCode)) {
+    *needRetry = false;
+    SCH_TASK_DLOG("task no more retry cause of errCode, errCode:%x - %s", errCode, tstrerror(errCode));
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (SCH_IS_DATA_SRC_TASK(pTask)) {
+    if ((pTask->execId + 1) >= SCH_TASK_NUM_OF_EPS(&pTask->plan->execNode)) {
+      *needRetry = false;
+      SCH_TASK_DLOG("task no more retry since all ep tried, execId:%d, epNum:%d", pTask->execId,
+                    SCH_TASK_NUM_OF_EPS(&pTask->plan->execNode));
+      return TSDB_CODE_SUCCESS;
+    }
+  } else {
+    int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);
+
+    if ((pTask->candidateIdx + 1) >= candidateNum && (TSDB_CODE_SCH_TIMEOUT_ERROR != errCode)) {
+      *needRetry = false;
+      SCH_TASK_DLOG("task no more retry since all candiates tried, candidateIdx:%d, candidateNum:%d",
+                    pTask->candidateIdx, candidateNum);
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+
+  *needRetry = true;
+  SCH_TASK_DLOG("task need the %dth retry, errCode:%x - %s", pTask->execId + 1, errCode, tstrerror(errCode));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schHandleTaskRetry(SSchJob *pJob, SSchTask *pTask) {
+  atomic_sub_fetch_32(&pTask->level->taskLaunchedNum, 1);
+
+  SCH_ERR_RET(schRemoveTaskFromExecList(pJob, pTask));
+  SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
+  
+  if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
+    SCH_ERR_RET(schLaunchTasksInFlowCtrlList(pJob, pTask));
+  }
+
+  schDeregisterTaskHb(pJob, pTask);
+
+  if (SCH_IS_DATA_SRC_TASK(pTask)) {
+    SCH_SWITCH_EPSET(&pTask->plan->execNode);
+  } else {
+    int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);  
+    if (++pTask->candidateIdx >= candidateNum) {
+      pTask->candidateIdx = 0;
+    }
+  }
+
+  SCH_ERR_RET(schLaunchTask(pJob, pTask));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schSetAddrsFromNodeList(SSchJob *pJob, SSchTask *pTask) {
+  int32_t addNum = 0;
+  int32_t nodeNum = 0;
+  
+  if (pJob->nodeList) {
+    nodeNum = taosArrayGetSize(pJob->nodeList);
+
+    for (int32_t i = 0; i < nodeNum && addNum < SCH_MAX_CANDIDATE_EP_NUM; ++i) {
+      SQueryNodeLoad *nload = taosArrayGet(pJob->nodeList, i);
+      SQueryNodeAddr *naddr = &nload->addr;
+      
+      if (NULL == taosArrayPush(pTask->candidateAddrs, naddr)) {
+        SCH_TASK_ELOG("taosArrayPush execNode to candidate addrs failed, addNum:%d, errno:%d", addNum, errno);
+        SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+      }
+
+      SCH_TASK_DLOG("set %dth candidate addr, id %d, fqdn:%s, port:%d", i, naddr->nodeId, SCH_GET_CUR_EP(naddr)->fqdn, SCH_GET_CUR_EP(naddr)->port);
+
+      ++addNum;
+    }
+  }
+
+  if (addNum <= 0) {
+    SCH_TASK_ELOG("no available execNode as candidates, nodeNum:%d", nodeNum);
+    SCH_ERR_RET(TSDB_CODE_TSC_NO_EXEC_NODE);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t schSetTaskCandidateAddrs(SSchJob *pJob, SSchTask *pTask) {
+  if (NULL != pTask->candidateAddrs) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pTask->candidateIdx = 0;
+  pTask->candidateAddrs = taosArrayInit(SCH_MAX_CANDIDATE_EP_NUM, sizeof(SQueryNodeAddr));
+  if (NULL == pTask->candidateAddrs) {
+    SCH_TASK_ELOG("taosArrayInit %d condidate addrs failed", SCH_MAX_CANDIDATE_EP_NUM);
+    SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+
+  if (pTask->plan->execNode.epSet.numOfEps > 0) {
+    if (NULL == taosArrayPush(pTask->candidateAddrs, &pTask->plan->execNode)) {
+      SCH_TASK_ELOG("taosArrayPush execNode to candidate addrs failed, errno:%d", errno);
+      SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+    }
+
+    SCH_TASK_DLOG("use execNode in plan as candidate addr, numOfEps:%d", pTask->plan->execNode.epSet.numOfEps);
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (SCH_IS_DATA_SRC_QRY_TASK(pTask)) {
+    SCH_TASK_ELOG("no execNode specifed for data src task, numOfEps:%d", pTask->plan->execNode.epSet.numOfEps);
+    SCH_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
+  }
+
+  SCH_ERR_RET(schSetAddrsFromNodeList(pJob, pTask));
+
+  /*
+    for (int32_t i = 0; i < job->dataSrcEps.numOfEps && addNum < SCH_MAX_CANDIDATE_EP_NUM; ++i) {
+      strncpy(epSet->fqdn[epSet->numOfEps], job->dataSrcEps.fqdn[i], sizeof(job->dataSrcEps.fqdn[i]));
+      epSet->port[epSet->numOfEps] = job->dataSrcEps.port[i];
+
+      ++epSet->numOfEps;
+    }
+  */
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schUpdateTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask, SEpSet* pEpSet) {
+  if (NULL == pTask->candidateAddrs || 1 != taosArrayGetSize(pTask->candidateAddrs)) {
+    SCH_TASK_ELOG("not able to update cndidate addr, addr num %d", (int32_t)(pTask->candidateAddrs ? taosArrayGetSize(pTask->candidateAddrs): 0));
+    SCH_ERR_RET(TSDB_CODE_APP_ERROR);
+  }
+
+  SQueryNodeAddr* pAddr = taosArrayGet(pTask->candidateAddrs, 0);
+
+  SEp* pOld = &pAddr->epSet.eps[pAddr->epSet.inUse];
+  SEp* pNew = &pEpSet->eps[pEpSet->inUse];
+
+  SCH_TASK_DLOG("update task ep from %s:%d to %s:%d", pOld->fqdn, pOld->port, pNew->fqdn, pNew->port);
+
+  memcpy(&pAddr->epSet, pEpSet, sizeof(pAddr->epSet));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t schRemoveTaskFromExecList(SSchJob *pJob, SSchTask *pTask) {
+  int32_t code = taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId));
+  if (code) {
+    SCH_TASK_ELOG("task failed to rm from execTask list, code:%x", code);
+    SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+void schDropTaskOnExecNode(SSchJob *pJob, SSchTask *pTask) {
+  if (NULL == pTask->execNodes) {
+    SCH_TASK_DLOG("no exec address, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+    return;
+  }
+
+  int32_t size = (int32_t)taosHashGetSize(pTask->execNodes);
+
+  if (size <= 0) {
+    SCH_TASK_DLOG("task has no execNodes, no need to drop it, status:%s", SCH_GET_TASK_STATUS_STR(pTask));
+    return;
+  }
+
+  SSchNodeInfo *nodeInfo = taosHashIterate(pTask->execNodes, NULL);
+  while (nodeInfo) {
+    SCH_SET_TASK_HANDLE(pTask, nodeInfo->handle);
+
+    schBuildAndSendMsg(pJob, pTask, &nodeInfo->addr, TDMT_SCH_DROP_TASK);
+
+    nodeInfo = taosHashIterate(pTask->execNodes, nodeInfo);
+  }
+
+  SCH_TASK_DLOG("task has been dropped on %d exec nodes", size);
+}
+
+
+
+int32_t schProcessOnTaskStatusRsp(SQueryNodeEpId* pEpId, SArray* pStatusList) {
+  int32_t taskNum = (int32_t)taosArrayGetSize(pStatusList);
+  SSchTask *pTask = NULL;
+  SSchJob *pJob = NULL;
+
+  qDebug("%d task status in hb rsp from nodeId:%d, fqdn:%s, port:%d", taskNum, pEpId->nodeId, pEpId->ep.fqdn, pEpId->ep.port);
+
+  for (int32_t i = 0; i < taskNum; ++i) {
+    STaskStatus *pStatus = taosArrayGet(pStatusList, i);
+    int32_t code = 0;
+    
+    qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d task status in server: %s", 
+      pStatus->queryId, pStatus->taskId, pStatus->execId, jobTaskStatusStr(pStatus->status));
+
+    if (schProcessOnCbBegin(&pJob, &pTask, pStatus->queryId, pStatus->refId, pStatus->taskId)) {
+      continue;
+    }
+
+    if (pStatus->execId != pTask->execId) {
+      //TODO
+      SCH_TASK_DLOG("execId %d mis-match current execId %d", pStatus->execId, pTask->execId);
+      schProcessOnCbEnd(pJob, pTask, 0);
+      continue;
+    }
+  
+    if (pStatus->status == JOB_TASK_STATUS_FAIL) {
+      // RECORD AND HANDLE ERROR!!!!
+      schProcessOnCbEnd(pJob, pTask, 0);
+      continue;
+    }
+
+    if (pStatus->status == JOB_TASK_STATUS_INIT) {
+      code = schRescheduleTask(pJob, pTask);
+    }
+
+    schProcessOnCbEnd(pJob, pTask, code);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schLaunchTaskImpl(SSchJob *pJob, SSchTask *pTask) {
+  int8_t  status = 0;
+  int32_t code = 0;
+
+  atomic_add_fetch_32(&pTask->level->taskLaunchedNum, 1);
+  pTask->execId++;
+
+  SCH_TASK_DLOG("start to launch task's %dth exec", pTask->execId);
+
+  SCH_LOG_TASK_START_TS(pTask);
+
+  if (schJobNeedToStop(pJob, &status)) {
+    SCH_TASK_DLOG("no need to launch task cause of job status %s", jobTaskStatusStr(status));
+    SCH_ERR_RET(TSDB_CODE_SCH_IGNORE_ERROR);
+  }
+
+  // NOTE: race condition: the task should be put into the hash table before send msg to server
+  if (SCH_GET_TASK_STATUS(pTask) != JOB_TASK_STATUS_EXEC) {
+    SCH_ERR_RET(schPushTaskToExecList(pJob, pTask));
+    SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_EXEC);
+  }
+
+  SSubplan *plan = pTask->plan;
+
+  if (NULL == pTask->msg) {  // TODO add more detailed reason for failure
+    code = qSubPlanToString(plan, &pTask->msg, &pTask->msgLen);
+    if (TSDB_CODE_SUCCESS != code) {
+      SCH_TASK_ELOG("failed to create physical plan, code:%s, msg:%p, len:%d", tstrerror(code), pTask->msg,
+                    pTask->msgLen);
+      SCH_ERR_RET(code);
+    } else {
+      SCH_TASK_DLOGL("physical plan len:%d, %s", pTask->msgLen, pTask->msg);
+    }
+  }
+
+  SCH_ERR_RET(schSetTaskCandidateAddrs(pJob, pTask));
+
+  if (SCH_IS_QUERY_JOB(pJob)) {
+    SCH_ERR_RET(schEnsureHbConnection(pJob, pTask));
+  }
+
+  SCH_ERR_RET(schBuildAndSendMsg(pJob, pTask, NULL, plan->msgType));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+// Note: no more error processing, handled in function internal
+int32_t schLaunchTask(SSchJob *pJob, SSchTask *pTask) {
+  bool    enough = false;
+  int32_t code = 0;
+
+  SCH_SET_TASK_HANDLE(pTask, NULL);
+
+  if (SCH_TASK_NEED_FLOW_CTRL(pJob, pTask)) {
+    SCH_ERR_JRET(schCheckIncTaskFlowQuota(pJob, pTask, &enough));
+
+    if (enough) {
+      SCH_ERR_JRET(schLaunchTaskImpl(pJob, pTask));
+    }
+  } else {
+    SCH_ERR_JRET(schLaunchTaskImpl(pJob, pTask));
+  }
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  SCH_RET(schProcessOnTaskFailure(pJob, pTask, code));
+}
+
+int32_t schLaunchLevelTasks(SSchJob *pJob, SSchLevel *level) {
+  SCH_ERR_RET(schChkJobNeedFlowCtrl(pJob, level));
+
+  for (int32_t i = 0; i < level->taskNum; ++i) {
+    SSchTask *pTask = taosArrayGet(level->subTasks, i);
+
+    SCH_ERR_RET(schLaunchTask(pJob, pTask));
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+void schDropTaskInHashList(SSchJob *pJob, SHashObj *list) {
+  if (!SCH_JOB_NEED_DROP(pJob)) {
+    return;
+  }
+
+  void *pIter = taosHashIterate(list, NULL);
+  while (pIter) {
+    SSchTask *pTask = *(SSchTask **)pIter;
+
+    schDropTaskOnExecNode(pJob, pTask);
+
+    pIter = taosHashIterate(list, pIter);
+  }
+}
+
+
+// Note: no more error processing, handled in function internal
+int32_t schLaunchFetchTask(SSchJob *pJob) {
+  int32_t code = 0;
+
+  void *resData = atomic_load_ptr(&pJob->resData);
+  if (resData) {
+    SCH_JOB_DLOG("res already fetched, res:%p", resData);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SCH_ERR_JRET(schBuildAndSendMsg(pJob, pJob->fetchTask, &pJob->resNode, TDMT_SCH_FETCH));
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  SCH_RET(schProcessOnTaskFailure(pJob, pJob->fetchTask, code));
+}
+
+
diff --git a/source/libs/scheduler/src/schUtil.c b/source/libs/scheduler/src/schUtil.c
index 73077cbf0f..f848dfa210 100644
--- a/source/libs/scheduler/src/schUtil.c
+++ b/source/libs/scheduler/src/schUtil.c
@@ -16,11 +16,25 @@
 #include "catalog.h"
 #include "command.h"
 #include "query.h"
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "tmsg.h"
 #include "tref.h"
 #include "trpc.h"
 
+FORCE_INLINE SSchJob *schAcquireJob(int64_t refId) { 
+  qDebug("sch acquire jobId:0x%"PRIx64, refId); 
+  return (SSchJob *)taosAcquireRef(schMgmt.jobRef, refId); 
+}
+
+FORCE_INLINE int32_t schReleaseJob(int64_t refId) { 
+  if (0 == refId) {
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  qDebug("sch release jobId:0x%"PRIx64, refId); 
+  return taosReleaseRef(schMgmt.jobRef, refId); 
+}
+
 char* schGetOpStr(SCH_OP_TYPE type) {
   switch (type) {
     case SCH_OP_NULL:
@@ -29,6 +43,8 @@ char* schGetOpStr(SCH_OP_TYPE type) {
       return "EXEC";
     case SCH_OP_FETCH:
       return "FETCH";
+    case SCH_OP_GET_STATUS:
+      return "GET STATUS";
     default:
       return "UNKNOWN";
   }
@@ -283,3 +299,20 @@ void schFreeSMsgSendInfo(SMsgSendInfo *msgSendInfo) {
   taosMemoryFree(msgSendInfo);
 }
 
+int32_t schGetTaskFromList(SHashObj *pTaskList, uint64_t taskId, SSchTask **pTask) {
+  int32_t s = taosHashGetSize(pTaskList);
+  if (s <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSchTask **task = taosHashGet(pTaskList, &taskId, sizeof(taskId));
+  if (NULL == task || NULL == (*task)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  *pTask = *task;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c
index e2389c2a75..ebc4014e88 100644
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
@@ -16,7 +16,7 @@
 #include "catalog.h"
 #include "command.h"
 #include "query.h"
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "tmsg.h"
 #include "tref.h"
 #include "trpc.h"
@@ -67,121 +67,45 @@ int32_t schedulerInit(SSchedulerCfg *cfg) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJobId, SQueryResult *pRes) {
-  qDebug("scheduler sync exec job start");
+int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJobId) {
+  qDebug("scheduler %s exec job start", pReq->syncReq ? "SYNC" : "ASYNC");
 
   int32_t code = 0;  
   SSchJob *pJob = NULL;
-  SCH_ERR_JRET(schInitJob(pReq, &pJob));
 
-  *pJobId = pJob->refId;
-  
-  SCH_ERR_JRET(schExecJobImpl(pReq, pJob, true));
+  SCH_ERR_JRET(schInitJob(pJobId, pReq));
+
+  SCH_ERR_JRET(schHandleOpBeginEvent(*pJobId, &pJob, SCH_OP_EXEC, pReq));
+
+  SCH_ERR_JRET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_INIT, pReq));
+
+  SCH_ERR_JRET(schSwitchJobStatus(pJob, JOB_TASK_STATUS_EXEC, pReq));
 
 _return:
-
-  if (code && NULL == pJob) {
-    qDestroyQueryPlan(pReq->pDag);
-  }
   
-  if (pJob) {
-    schSetJobQueryRes(pJob, pRes);
-    schReleaseJob(pJob->refId);
-  }
-
-  return code;
+  SCH_RET(schHandleOpEndEvent(pJob, SCH_OP_EXEC, pReq, code));
 }
 
-int32_t schedulerAsyncExecJob(SSchedulerReq *pReq, int64_t *pJobId) {
-  qDebug("scheduler async exec job start");
+int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq) {
+  qDebug("scheduler %s fetch rows start", pReq->syncReq ? "SYNC" : "ASYNC");
 
-  int32_t code = 0;  
+  int32_t  code = 0;
   SSchJob *pJob = NULL;
-  SCH_ERR_JRET(schInitJob(pReq, &pJob));
 
-  *pJobId = pJob->refId;
-  
-  SCH_ERR_JRET(schExecJobImpl(pReq, pJob, false));
+  SCH_ERR_JRET(schHandleOpBeginEvent(jobId, &pJob, SCH_OP_FETCH, pReq));
+
+  SCH_ERR_JRET(schJobFetchRows(pJob));
 
 _return:
 
-  if (code && NULL == pJob) {
-    qDestroyQueryPlan(pReq->pDag);
-  }
-  
-  if (pJob) {
-    schReleaseJob(pJob->refId);
-  }
-
-  return code;
+  SCH_RET(schHandleOpEndEvent(pJob, SCH_OP_FETCH, pReq, code));
 }
 
-int32_t schedulerFetchRows(int64_t job, void **pData) {
-  qDebug("scheduler sync fetch rows start");
-
-  if (NULL == pData) {
-    SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
-  }
-
+int32_t schedulerGetTasksStatus(int64_t jobId, SArray *pSub) {
   int32_t  code = 0;
-  SSchJob *pJob = schAcquireJob(job);
-  if (NULL == pJob) {
-    qError("acquire job from jobRef list failed, may be dropped, jobId:0x%" PRIx64, job);
-    SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
+  SSchJob *pJob = NULL;
 
-  SCH_ERR_RET(schBeginOperation(pJob, SCH_OP_FETCH, true));
-
-  pJob->userRes.fetchRes = pData;
-  code = schFetchRows(pJob);
-
-  schReleaseJob(job);
-
-  SCH_RET(code);
-}
-
-void schedulerAsyncFetchRows(int64_t job, schedulerFetchFp fp, void* param) {
-  qDebug("scheduler async fetch rows start");
-
-  int32_t code = 0;
-  if (NULL == fp || NULL == param) {
-    SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
-  }
-
-  SSchJob *pJob = schAcquireJob(job);
-  if (NULL == pJob) {
-    qError("acquire sch job from job list failed, may be dropped, jobId:0x%" PRIx64, job);
-    SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
-
-  SCH_ERR_JRET(schBeginOperation(pJob, SCH_OP_FETCH, false));
-  
-  pJob->userRes.fetchFp = fp;
-  pJob->userRes.userParam = param;
-  
-  SCH_ERR_JRET(schAsyncFetchRows(pJob));
-
-_return:
-
-  if (code) {
-    fp(NULL, param, code);
-  }
-  
-  schReleaseJob(job);
-}
-
-int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub) {
-  int32_t  code = 0;
-  SSchJob *pJob = schAcquireJob(job);
-  if (NULL == pJob) {
-    qDebug("acquire job from jobRef list failed, may not started or dropped, refId:0x%" PRIx64, job);
-    SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
-
-  if (pJob->status < JOB_TASK_STATUS_NOT_START || pJob->levelNum <= 0 || NULL == pJob->levels) {
-    qDebug("job not initialized or not executable job, refId:0x%" PRIx64, job);
-    SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
+  SCH_ERR_JRET(schHandleOpBeginEvent(jobId, &pJob, SCH_OP_GET_STATUS, NULL));
 
   for (int32_t i = pJob->levelNum - 1; i >= 0; --i) {
     SSchLevel *pLevel = taosArrayGet(pJob->levels, i);
@@ -198,23 +122,7 @@ int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub) {
 
 _return:
 
-  schReleaseJob(job);
-
-  SCH_RET(code);
-}
-
-int32_t scheduleCancelJob(int64_t job) {
-  SSchJob *pJob = schAcquireJob(job);
-  if (NULL == pJob) {
-    qError("acquire job from jobRef list failed, may be dropped, jobId:0x%" PRIx64, job);
-    SCH_ERR_RET(TSDB_CODE_SCH_STATUS_ERROR);
-  }
-
-  int32_t code = schCancelJob(pJob);
-
-  schReleaseJob(job);
-
-  SCH_RET(code);
+  SCH_RET(schHandleOpEndEvent(pJob, SCH_OP_GET_STATUS, NULL, code));
 }
 
 void schedulerStopQueryHb(void *pTrans) {
@@ -225,33 +133,23 @@ void schedulerStopQueryHb(void *pTrans) {
   schCleanClusterHb(pTrans);
 }
 
-void schedulerFreeJob(int64_t* job, int32_t errCode) {
-  if (0 == *job) {
+void schedulerFreeJob(int64_t* jobId, int32_t errCode) {
+  if (0 == *jobId) {
     return;
   }
-  
-  SSchJob *pJob = schAcquireJob(*job);
+
+  SSchJob *pJob = schAcquireJob(*jobId);
   if (NULL == pJob) {
-    qError("acquire sch job failed, may be dropped, jobId:0x%" PRIx64, *job);
-    *job = 0;
+    qError("Acquire sch job failed, may be dropped, jobId:0x%" PRIx64, *jobId);
     return;
   }
 
-  int32_t code = schProcessOnJobDropped(pJob, errCode);
-  if (TSDB_CODE_SCH_JOB_IS_DROPPING == code) {
-    SCH_JOB_DLOG("sch job is already dropping, refId:0x%" PRIx64, *job);
-    *job = 0;
+  if (schJobDone(pJob)) {
     return;
   }
 
-  SCH_JOB_DLOG("start to remove job from jobRef list, refId:0x%" PRIx64, *job);
-
-  if (taosRemoveRef(schMgmt.jobRef, *job)) {
-    SCH_JOB_ELOG("remove job from job list failed, refId:0x%" PRIx64, *job);
-  }
-
-  schReleaseJob(*job);
-  *job = 0;
+  schSwitchJobStatus(pJob, JOB_TASK_STATUS_DROP, (void*)&errCode);
+  *jobId = 0;
 }
 
 void schedulerDestroy(void) {
diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp
index 7fe6cc22bf..d6b1baf978 100644
--- a/source/libs/scheduler/test/schedulerTests.cpp
+++ b/source/libs/scheduler/test/schedulerTests.cpp
@@ -50,7 +50,7 @@
 #pragma GCC diagnostic ignored "-Wreturn-type"
 #pragma GCC diagnostic ignored "-Wformat"
 
-#include "schedulerInt.h"
+#include "schInt.h"
 #include "stub.h"
 #include "tref.h"
 
@@ -87,7 +87,7 @@ void schtInitLogFile() {
 
 }
 
-void schtQueryCb(SQueryResult* pResult, void* param, int32_t code) {
+void schtQueryCb(SExecResult* pResult, void* param, int32_t code) {
   assert(TSDB_CODE_SUCCESS == code);
   *(int32_t*)param = 1;
 }
@@ -507,14 +507,15 @@ void* schtRunJobThread(void *aa) {
     SRequestConnInfo conn = {0};
     conn.pTrans = mockPointer;
     SSchedulerReq req = {0};    
+    req.syncReq = false;
     req.pConn = &conn;
     req.pNodeList = qnodeList;
     req.pDag = &dag;
     req.sql = "select * from tb";
     req.execFp = schtQueryCb;
-    req.execParam = &queryDone;
+    req.cbParam = &queryDone;
     
-    code = schedulerAsyncExecJob(&req, &queryJobRefId);      
+    code = schedulerExecJob(&req, &queryJobRefId);      
     assert(code == 0);
 
     pJob = schAcquireJob(queryJobRefId);
@@ -584,7 +585,10 @@ void* schtRunJobThread(void *aa) {
     atomic_store_32(&schtStartFetch, 1);
 
     void *data = NULL;  
-    code = schedulerFetchRows(queryJobRefId, &data);
+    req.syncReq = true;
+    req.pFetchRes = &data;
+    
+    code = schedulerFetchRows(queryJobRefId, &req);
     assert(code == 0 || code);
 
     if (0 == code) {
@@ -594,7 +598,7 @@ void* schtRunJobThread(void *aa) {
     }
 
     data = NULL;
-    code = schedulerFetchRows(queryJobRefId, &data);
+    code = schedulerFetchRows(queryJobRefId, &req);
     assert(code == 0 || code);
     
     schtFreeQueryJob(0);
@@ -658,15 +662,15 @@ TEST(queryTest, normalCase) {
 
   SRequestConnInfo conn = {0};
   conn.pTrans = mockPointer;
-  SSchedulerReq req = {0};    
+  SSchedulerReq req = {0};   
   req.pConn = &conn;
   req.pNodeList = qnodeList;
   req.pDag = &dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
-  req.execParam = &queryDone;
+  req.cbParam = &queryDone;
     
-  code = schedulerAsyncExecJob(&req, &job);  
+  code = schedulerExecJob(&req, &job);  
   ASSERT_EQ(code, 0);
 
   
@@ -709,7 +713,10 @@ TEST(queryTest, normalCase) {
   taosThreadCreate(&(thread1), &thattr, schtCreateFetchRspThread, &job);
 
   void *data = NULL;  
-  code = schedulerFetchRows(job, &data);
+  req.syncReq = true;
+  req.pFetchRes = &data;
+
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
 
   SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)data;
@@ -718,7 +725,7 @@ TEST(queryTest, normalCase) {
   taosMemoryFreeClear(data);
 
   data = NULL;
-  code = schedulerFetchRows(job, &data);
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
   ASSERT_TRUE(data == NULL);
 
@@ -768,8 +775,8 @@ TEST(queryTest, readyFirstCase) {
   req.pDag = &dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
-  req.execParam = &queryDone;
-  code = schedulerAsyncExecJob(&req, &job);
+  req.cbParam = &queryDone;
+  code = schedulerExecJob(&req, &job);
   ASSERT_EQ(code, 0);
 
   
@@ -813,7 +820,9 @@ TEST(queryTest, readyFirstCase) {
   taosThreadCreate(&(thread1), &thattr, schtCreateFetchRspThread, &job);
 
   void *data = NULL;  
-  code = schedulerFetchRows(job, &data);
+  req.syncReq = true;
+  req.pFetchRes = &data;
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
 
   SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)data;
@@ -822,7 +831,7 @@ TEST(queryTest, readyFirstCase) {
   taosMemoryFreeClear(data);
 
   data = NULL;
-  code = schedulerFetchRows(job, &data);
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
   ASSERT_TRUE(data == NULL);
 
@@ -875,9 +884,9 @@ TEST(queryTest, flowCtrlCase) {
   req.pDag = &dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
-  req.execParam = &queryDone;
+  req.cbParam = &queryDone;
 
-  code = schedulerAsyncExecJob(&req, &job);
+  code = schedulerExecJob(&req, &job);
   ASSERT_EQ(code, 0);
 
   
@@ -925,7 +934,9 @@ TEST(queryTest, flowCtrlCase) {
   taosThreadCreate(&(thread1), &thattr, schtCreateFetchRspThread, &job);
 
   void *data = NULL;  
-  code = schedulerFetchRows(job, &data);
+  req.syncReq = true;
+  req.pFetchRes = &data;
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
 
   SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)data;
@@ -934,7 +945,7 @@ TEST(queryTest, flowCtrlCase) {
   taosMemoryFreeClear(data);
 
   data = NULL;
-  code = schedulerFetchRows(job, &data);
+  code = schedulerFetchRows(job, &req);
   ASSERT_EQ(code, 0);
   ASSERT_TRUE(data == NULL);
 
@@ -978,7 +989,7 @@ TEST(insertTest, normalCase) {
   TdThread thread1;
   taosThreadCreate(&(thread1), &thattr, schtSendRsp, &insertJobRefId);
 
-  SQueryResult res = {0};
+  SExecResult res = {0};
 
   SRequestConnInfo conn = {0};
   conn.pTrans = mockPointer;
@@ -988,9 +999,9 @@ TEST(insertTest, normalCase) {
   req.pDag = &dag;
   req.sql = "insert into tb values(now,1)";
   req.execFp = schtQueryCb;
-  req.execParam = NULL;
+  req.cbParam = NULL;
   
-  code = schedulerExecJob(&req, &insertJobRefId, &res);
+  code = schedulerExecJob(&req, &insertJobRefId);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(res.numOfRows, 20);
 
diff --git a/source/libs/sync/inc/syncRaftCfg.h b/source/libs/sync/inc/syncRaftCfg.h
index 521ca6068d..086a6aa074 100644
--- a/source/libs/sync/inc/syncRaftCfg.h
+++ b/source/libs/sync/inc/syncRaftCfg.h
@@ -36,7 +36,7 @@ typedef struct SRaftCfg {
   TdFilePtr pFile;
   char      path[TSDB_FILENAME_LEN * 2];
   int8_t    isStandBy;
-  int8_t    snapshotEnable;
+  int8_t    snapshotStrategy;
   SyncIndex lastConfigIndex;
 
   SyncIndex configIndexArr[MAX_CONFIG_INDEX_COUNT];
@@ -49,20 +49,20 @@ int32_t   raftCfgClose(SRaftCfg *pRaftCfg);
 int32_t   raftCfgPersist(SRaftCfg *pRaftCfg);
 int32_t   raftCfgAddConfigIndex(SRaftCfg *pRaftCfg, SyncIndex configIndex);
 
-cJSON * syncCfg2Json(SSyncCfg *pSyncCfg);
-char *  syncCfg2Str(SSyncCfg *pSyncCfg);
-char *  syncCfg2SimpleStr(SSyncCfg *pSyncCfg);
+cJSON  *syncCfg2Json(SSyncCfg *pSyncCfg);
+char   *syncCfg2Str(SSyncCfg *pSyncCfg);
+char   *syncCfg2SimpleStr(SSyncCfg *pSyncCfg);
 int32_t syncCfgFromJson(const cJSON *pRoot, SSyncCfg *pSyncCfg);
 int32_t syncCfgFromStr(const char *s, SSyncCfg *pSyncCfg);
 
-cJSON * raftCfg2Json(SRaftCfg *pRaftCfg);
-char *  raftCfg2Str(SRaftCfg *pRaftCfg);
+cJSON  *raftCfg2Json(SRaftCfg *pRaftCfg);
+char   *raftCfg2Str(SRaftCfg *pRaftCfg);
 int32_t raftCfgFromJson(const cJSON *pRoot, SRaftCfg *pRaftCfg);
 int32_t raftCfgFromStr(const char *s, SRaftCfg *pRaftCfg);
 
 typedef struct SRaftCfgMeta {
   int8_t    isStandBy;
-  int8_t    snapshotEnable;
+  int8_t    snapshotStrategy;
   SyncIndex lastConfigIndex;
 } SRaftCfgMeta;
 
diff --git a/source/libs/sync/src/syncElection.c b/source/libs/sync/src/syncElection.c
index 816430b5b5..2712b4edc6 100644
--- a/source/libs/sync/src/syncElection.c
+++ b/source/libs/sync/src/syncElection.c
@@ -96,12 +96,20 @@ int32_t syncNodeElect(SSyncNode* pSyncNode) {
     return ret;
   }
 
-  if (pSyncNode->pRaftCfg->snapshotEnable) {
-    ret = syncNodeRequestVotePeersSnapshot(pSyncNode);
-  } else {
-    ret = syncNodeRequestVotePeers(pSyncNode);
-  }
+  switch (pSyncNode->pRaftCfg->snapshotStrategy) {
+    case SYNC_STRATEGY_NO_SNAPSHOT:
+      ret = syncNodeRequestVotePeers(pSyncNode);
+      break;
 
+    case SYNC_STRATEGY_STANDARD_SNAPSHOT:
+    case SYNC_STRATEGY_WAL_FIRST:
+      ret = syncNodeRequestVotePeersSnapshot(pSyncNode);
+      break;
+
+    default:
+      ret = syncNodeRequestVotePeers(pSyncNode);
+      break;
+  }
   ASSERT(ret == 0);
   syncNodeResetElectTimer(pSyncNode);
 
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index cefd306f7d..d1ebc02655 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -672,12 +672,12 @@ int32_t syncNodeProposeBatch(SSyncNode* pSyncNode, SRpcMsg* pMsgArr, bool* pIsWe
   }
 
   if (arrSize > SYNC_MAX_BATCH_SIZE) {
-    syncNodeErrorLog(pSyncNode, "sync propose match batch error");
+    syncNodeErrorLog(pSyncNode, "sync propose batch error");
     terrno = TSDB_CODE_SYN_BATCH_ERROR;
     return -1;
   }
 
-  if (pSyncNode->state == TAOS_SYNC_STATE_LEADER) {
+  if (pSyncNode->state != TAOS_SYNC_STATE_LEADER) {
     syncNodeErrorLog(pSyncNode, "sync propose not leader");
     terrno = TSDB_CODE_SYN_NOT_LEADER;
     return -1;
@@ -711,7 +711,7 @@ int32_t syncNodeProposeBatch(SSyncNode* pSyncNode, SRpcMsg* pMsgArr, bool* pIsWe
     // enqueue msg ok
 
   } else {
-    sError("enqueue msg error, FpEqMsg is NULL");
+    sError("vgId:%d, enqueue msg error, FpEqMsg is NULL", pSyncNode->vgId);
     terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
     return -1;
   }
@@ -730,7 +730,7 @@ int32_t syncNodePropose(SSyncNode* pSyncNode, SRpcMsg* pMsg, bool isWeak) {
     if (pSyncNode->changing && pMsg->msgType != TDMT_SYNC_CONFIG_CHANGE_FINISH) {
       ret = -1;
       terrno = TSDB_CODE_SYN_PROPOSE_NOT_READY;
-      sError("sync propose not ready, type:%s,%d", TMSG_INFO(pMsg->msgType), pMsg->msgType);
+      sError("vgId:%d, sync propose not ready, type:%s,%d", pSyncNode->vgId, TMSG_INFO(pMsg->msgType), pMsg->msgType);
       goto _END;
     }
 
@@ -739,7 +739,8 @@ int32_t syncNodePropose(SSyncNode* pSyncNode, SRpcMsg* pMsg, bool isWeak) {
       if (!syncNodeCanChange(pSyncNode)) {
         ret = -1;
         terrno = TSDB_CODE_SYN_RECONFIG_NOT_READY;
-        sError("sync reconfig not ready, type:%s,%d", TMSG_INFO(pMsg->msgType), pMsg->msgType);
+        sError("vgId:%d, sync reconfig not ready, type:%s,%d", pSyncNode->vgId, TMSG_INFO(pMsg->msgType),
+               pMsg->msgType);
         goto _END;
       }
 
@@ -780,7 +781,7 @@ int32_t syncNodePropose(SSyncNode* pSyncNode, SRpcMsg* pMsg, bool isWeak) {
       } else {
         ret = -1;
         terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
-        sError("enqueue msg error, FpEqMsg is NULL");
+        sError("vgId:%d, enqueue msg error, FpEqMsg is NULL", pSyncNode->vgId);
       }
     }
 
@@ -790,7 +791,7 @@ int32_t syncNodePropose(SSyncNode* pSyncNode, SRpcMsg* pMsg, bool isWeak) {
   } else {
     ret = -1;
     terrno = TSDB_CODE_SYN_NOT_LEADER;
-    sError("sync propose not leader, %s", syncUtilState2String(pSyncNode->state));
+    sError("vgId:%d, sync propose not leader, %s", pSyncNode->vgId, syncUtilState2String(pSyncNode->state));
     goto _END;
   }
 
@@ -820,7 +821,7 @@ SSyncNode* syncNodeOpen(const SSyncInfo* pOldSyncInfo) {
     // create a new raft config file
     SRaftCfgMeta meta;
     meta.isStandBy = pSyncInfo->isStandBy;
-    meta.snapshotEnable = pSyncInfo->snapshotStrategy;
+    meta.snapshotStrategy = pSyncInfo->snapshotStrategy;
     meta.lastConfigIndex = SYNC_INDEX_INVALID;
     ret = raftCfgCreateFile((SSyncCfg*)&(pSyncInfo->syncCfg), meta, pSyncNode->configPath);
     ASSERT(ret == 0);
@@ -969,7 +970,7 @@ SSyncNode* syncNodeOpen(const SSyncInfo* pOldSyncInfo) {
   pSyncNode->FpOnSnapshotSend = syncNodeOnSnapshotSendCb;
   pSyncNode->FpOnSnapshotRsp = syncNodeOnSnapshotRspCb;
 
-  if (pSyncNode->pRaftCfg->snapshotEnable) {
+  if (pSyncNode->pRaftCfg->snapshotStrategy) {
     sInfo("sync node use snapshot");
     pSyncNode->FpOnRequestVote = syncNodeOnRequestVoteSnapshotCb;
     pSyncNode->FpOnRequestVoteReply = syncNodeOnRequestVoteReplySnapshotCb;
@@ -1107,7 +1108,7 @@ void syncNodeClose(SSyncNode* pSyncNode) {
 // option
 // bool syncNodeSnapshotEnable(SSyncNode* pSyncNode) { return pSyncNode->pRaftCfg->snapshotEnable; }
 
-ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode) { return pSyncNode->pRaftCfg->snapshotEnable; }
+ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode) { return pSyncNode->pRaftCfg->snapshotStrategy; }
 
 // ping --------------
 int32_t syncNodePing(SSyncNode* pSyncNode, const SRaftId* destRaftId, SyncPing* pMsg) {
@@ -2496,6 +2497,15 @@ int32_t syncNodeOnClientRequestBatchCb(SSyncNode* ths, SyncClientRequestBatch* p
   SWal*              pWal = pData->pWal;
   walFsync(pWal, true);
 
+  if (ths->replicaNum > 1) {
+    // if mulit replica, start replicate right now
+    syncNodeReplicate(ths);
+
+  } else if (ths->replicaNum == 1) {
+    // one replica
+    syncMaybeAdvanceCommitIndex(ths);
+  }
+
   return 0;
 }
 
diff --git a/source/libs/sync/src/syncRaftCfg.c b/source/libs/sync/src/syncRaftCfg.c
index ec3f18132d..7eb7eb0db1 100644
--- a/source/libs/sync/src/syncRaftCfg.c
+++ b/source/libs/sync/src/syncRaftCfg.c
@@ -101,7 +101,7 @@ cJSON *syncCfg2Json(SSyncCfg *pSyncCfg) {
 
 char *syncCfg2Str(SSyncCfg *pSyncCfg) {
   cJSON *pJson = syncCfg2Json(pSyncCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -109,7 +109,7 @@ char *syncCfg2Str(SSyncCfg *pSyncCfg) {
 char *syncCfg2SimpleStr(SSyncCfg *pSyncCfg) {
   if (pSyncCfg != NULL) {
     int32_t len = 512;
-    char *  s = taosMemoryMalloc(len);
+    char   *s = taosMemoryMalloc(len);
     memset(s, 0, len);
 
     snprintf(s, len, "{replica-num:%d, my-index:%d, ", pSyncCfg->replicaNum, pSyncCfg->myIndex);
@@ -182,7 +182,7 @@ cJSON *raftCfg2Json(SRaftCfg *pRaftCfg) {
   cJSON *pRoot = cJSON_CreateObject();
   cJSON_AddItemToObject(pRoot, "SSyncCfg", syncCfg2Json(&(pRaftCfg->cfg)));
   cJSON_AddNumberToObject(pRoot, "isStandBy", pRaftCfg->isStandBy);
-  cJSON_AddNumberToObject(pRoot, "snapshotEnable", pRaftCfg->snapshotEnable);
+  cJSON_AddNumberToObject(pRoot, "snapshotStrategy", pRaftCfg->snapshotStrategy);
 
   char buf64[128];
   snprintf(buf64, sizeof(buf64), "%ld", pRaftCfg->lastConfigIndex);
@@ -205,7 +205,7 @@ cJSON *raftCfg2Json(SRaftCfg *pRaftCfg) {
 
 char *raftCfg2Str(SRaftCfg *pRaftCfg) {
   cJSON *pJson = raftCfg2Json(pRaftCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -228,7 +228,7 @@ int32_t raftCfgCreateFile(SSyncCfg *pCfg, SRaftCfgMeta meta, const char *path) {
   SRaftCfg raftCfg;
   raftCfg.cfg = *pCfg;
   raftCfg.isStandBy = meta.isStandBy;
-  raftCfg.snapshotEnable = meta.snapshotEnable;
+  raftCfg.snapshotStrategy = meta.snapshotStrategy;
   raftCfg.lastConfigIndex = meta.lastConfigIndex;
   raftCfg.configIndexCount = 1;
   memset(raftCfg.configIndexArr, 0, sizeof(raftCfg.configIndexArr));
@@ -257,8 +257,8 @@ int32_t raftCfgFromJson(const cJSON *pRoot, SRaftCfg *pRaftCfg) {
   cJSON *pJsonIsStandBy = cJSON_GetObjectItem(pJson, "isStandBy");
   pRaftCfg->isStandBy = cJSON_GetNumberValue(pJsonIsStandBy);
 
-  cJSON *pJsonSnapshotEnable = cJSON_GetObjectItem(pJson, "snapshotEnable");
-  pRaftCfg->snapshotEnable = cJSON_GetNumberValue(pJsonSnapshotEnable);
+  cJSON *pJsonSnapshotStrategy = cJSON_GetObjectItem(pJson, "snapshotStrategy");
+  pRaftCfg->snapshotStrategy = cJSON_GetNumberValue(pJsonSnapshotStrategy);
 
   cJSON *pJsonLastConfigIndex = cJSON_GetObjectItem(pJson, "lastConfigIndex");
   pRaftCfg->lastConfigIndex = atoll(cJSON_GetStringValue(pJsonLastConfigIndex));
@@ -280,7 +280,7 @@ int32_t raftCfgFromJson(const cJSON *pRoot, SRaftCfg *pRaftCfg) {
     (pRaftCfg->configIndexArr)[i] = atoll(pIndex->valuestring);
   }
 
-  cJSON * pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
+  cJSON  *pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
   int32_t code = syncCfgFromJson(pJsonSyncCfg, &(pRaftCfg->cfg));
   ASSERT(code == 0);
 
diff --git a/source/libs/sync/src/syncReplication.c b/source/libs/sync/src/syncReplication.c
index bcca44130a..da31e9c4c4 100644
--- a/source/libs/sync/src/syncReplication.c
+++ b/source/libs/sync/src/syncReplication.c
@@ -132,10 +132,6 @@ int32_t syncNodeAppendEntriesPeersSnapshot2(SSyncNode* pSyncNode) {
     SyncIndex preLogIndex = syncNodeGetPreIndex(pSyncNode, nextIndex);
     SyncTerm  preLogTerm = syncNodeGetPreTerm(pSyncNode, nextIndex);
     if (preLogTerm == SYNC_TERM_INVALID) {
-      SSyncSnapshotSender* pSender = syncNodeGetSnapshotSender(pSyncNode, pDestId);
-      ASSERT(pSender != NULL);
-      ASSERT(!snapshotSenderIsStart(pSender));
-
       SyncIndex newNextIndex = syncNodeGetLastIndex(pSyncNode) + 1;
       syncIndexMgrSetIndex(pSyncNode->pNextIndex, pDestId, newNextIndex);
       syncIndexMgrSetIndex(pSyncNode->pMatchIndex, pDestId, SYNC_INDEX_INVALID);
@@ -145,26 +141,32 @@ int32_t syncNodeAppendEntriesPeersSnapshot2(SSyncNode* pSyncNode) {
       return -1;
     }
 
+    // entry pointer array
     SSyncRaftEntry* entryPArr[SYNC_MAX_BATCH_SIZE];
     memset(entryPArr, 0, sizeof(entryPArr));
 
+    // get entry batch
     int32_t   getCount = 0;
     SyncIndex getEntryIndex = nextIndex;
     for (int32_t i = 0; i < pSyncNode->batchSize; ++i) {
-      SSyncRaftEntry* pEntry;
+      SSyncRaftEntry* pEntry = NULL;
       int32_t         code = pSyncNode->pLogStore->syncLogGetEntry(pSyncNode->pLogStore, getEntryIndex, &pEntry);
       if (code == 0) {
         ASSERT(pEntry != NULL);
         entryPArr[i] = pEntry;
         getCount++;
+        getEntryIndex++;
+
       } else {
         break;
       }
     }
 
+    // build msg
     SyncAppendEntriesBatch* pMsg = syncAppendEntriesBatchBuild(entryPArr, getCount, pSyncNode->vgId);
     ASSERT(pMsg != NULL);
 
+    // free entries
     for (int32_t i = 0; i < pSyncNode->batchSize; ++i) {
       SSyncRaftEntry* pEntry = entryPArr[i];
       if (pEntry != NULL) {
@@ -197,12 +199,6 @@ int32_t syncNodeAppendEntriesPeersSnapshot(SSyncNode* pSyncNode) {
   syncIndexMgrLog2("begin append entries peers pNextIndex:", pSyncNode->pNextIndex);
   syncIndexMgrLog2("begin append entries peers pMatchIndex:", pSyncNode->pMatchIndex);
   logStoreSimpleLog2("begin append entries peers LogStore:", pSyncNode->pLogStore);
-  if (gRaftDetailLog) {
-    SSnapshot snapshot;
-    pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
-    sTrace("begin append entries peers, snapshot.lastApplyIndex:%ld, snapshot.lastApplyTerm:%lu",
-           snapshot.lastApplyIndex, snapshot.lastApplyTerm);
-  }
 
   int32_t ret = 0;
   for (int i = 0; i < pSyncNode->peersNum; ++i) {
@@ -224,9 +220,6 @@ int32_t syncNodeAppendEntriesPeersSnapshot(SSyncNode* pSyncNode) {
       return -1;
     }
 
-    // batch optimized
-    // SyncIndex lastIndex = syncUtilMinIndex(pSyncNode->pLogStore->getLastIndex(pSyncNode->pLogStore), nextIndex);
-
     // prepare entry
     SyncAppendEntries* pMsg = NULL;
 
@@ -283,11 +276,24 @@ int32_t syncNodeReplicate(SSyncNode* pSyncNode) {
   // start replicate
   int32_t ret = 0;
 
-  if (pSyncNode->pRaftCfg->snapshotEnable) {
-    ret = syncNodeAppendEntriesPeersSnapshot(pSyncNode);
-  } else {
-    ret = syncNodeAppendEntriesPeers(pSyncNode);
+  switch (pSyncNode->pRaftCfg->snapshotStrategy) {
+    case SYNC_STRATEGY_NO_SNAPSHOT:
+      ret = syncNodeAppendEntriesPeers(pSyncNode);
+      break;
+
+    case SYNC_STRATEGY_STANDARD_SNAPSHOT:
+      ret = syncNodeAppendEntriesPeersSnapshot(pSyncNode);
+      break;
+
+    case SYNC_STRATEGY_WAL_FIRST:
+      ret = syncNodeAppendEntriesPeersSnapshot2(pSyncNode);
+      break;
+
+    default:
+      ret = syncNodeAppendEntriesPeers(pSyncNode);
+      break;
   }
+
   return ret;
 }
 
diff --git a/source/libs/sync/test/syncRaftCfgTest.cpp b/source/libs/sync/test/syncRaftCfgTest.cpp
index 0f111ef22c..a3773604fb 100644
--- a/source/libs/sync/test/syncRaftCfgTest.cpp
+++ b/source/libs/sync/test/syncRaftCfgTest.cpp
@@ -83,7 +83,7 @@ void test3() {
   } else {
     SRaftCfgMeta meta;
     meta.isStandBy = 7;
-    meta.snapshotEnable = 9;
+    meta.snapshotStrategy = 9;
     meta.lastConfigIndex = 789;
     raftCfgCreateFile(pCfg, meta, s);
     printf("%s create json file: %s \n", (char*)__FUNCTION__, s);
@@ -108,7 +108,7 @@ void test5() {
 
   pCfg->cfg.myIndex = taosGetTimestampSec();
   pCfg->isStandBy += 2;
-  pCfg->snapshotEnable += 3;
+  pCfg->snapshotStrategy += 3;
   pCfg->lastConfigIndex += 1000;
 
   pCfg->configIndexCount = 5;
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index cb943b9d28..556fd78360 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -58,6 +58,15 @@ typedef struct TdFile {
 
 #define FILE_WITH_LOCK 1
 
+typedef struct AutoDelFile * AutoDelFilePtr;
+typedef struct AutoDelFile {
+  char           *name;
+  AutoDelFilePtr  lastAutoDelFilePtr;
+} AutoDelFile;
+static TdThreadMutex autoDelFileLock;
+static AutoDelFilePtr nowAutoDelFilePtr = NULL;
+static TdThreadOnce autoDelFileInit = PTHREAD_ONCE_INIT;
+
 void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath) {
 #ifdef WINDOWS
   const char *tdengineTmpFileNamePrefix = "tdengine-";
@@ -238,7 +247,33 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) {
   return 0;
 }
 
-void autoDelFileListAdd(const char *path) { return; }
+void autoDelFileList() {
+  taosThreadMutexLock(&autoDelFileLock);
+  while (nowAutoDelFilePtr != NULL) {
+    taosRemoveFile(nowAutoDelFilePtr->name);
+    AutoDelFilePtr tmp = nowAutoDelFilePtr->lastAutoDelFilePtr;
+    taosMemoryFree(nowAutoDelFilePtr->name);
+    taosMemoryFree(nowAutoDelFilePtr);
+    nowAutoDelFilePtr = tmp;
+  }
+  taosThreadMutexUnlock(&autoDelFileLock);
+  taosThreadMutexDestroy(&autoDelFileLock);
+}
+
+void autoDelFileListInit() {
+  taosThreadMutexInit(&autoDelFileLock, NULL);
+  atexit(autoDelFileList);
+}
+
+void autoDelFileListAdd(const char *path) {
+  taosThreadOnce(&autoDelFileInit, autoDelFileListInit);
+  taosThreadMutexLock(&autoDelFileLock);
+  AutoDelFilePtr tmp = taosMemoryMalloc(sizeof(AutoDelFile));
+  tmp->lastAutoDelFilePtr = nowAutoDelFilePtr;
+  tmp->name = taosMemoryStrDup(path);
+  nowAutoDelFilePtr = tmp;
+  taosThreadMutexUnlock(&autoDelFileLock);
+}
 
 TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
   int   fd = -1;
@@ -283,10 +318,6 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
     }
   }
 
-  if (tdFileOptions & TD_FILE_AUTO_DEL) {
-    autoDelFileListAdd(path);
-  }
-
   TdFilePtr pFile = (TdFilePtr)taosMemoryMalloc(sizeof(TdFile));
   if (pFile == NULL) {
     if (fd >= 0) close(fd);
@@ -299,6 +330,9 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
   pFile->fd = fd;
   pFile->fp = fp;
   pFile->refId = 0;
+  if (tdFileOptions & TD_FILE_AUTO_DEL) {
+    autoDelFileListAdd(path);
+  }
   return pFile;
 }
 
diff --git a/source/os/src/osMemory.c b/source/os/src/osMemory.c
index aa25b85342..07575336a1 100644
--- a/source/os/src/osMemory.c
+++ b/source/os/src/osMemory.c
@@ -282,14 +282,14 @@ void *taosMemoryRealloc(void *ptr, int32_t size) {
 #endif
 }
 
-void *taosMemoryStrDup(void *ptr) {
+void *taosMemoryStrDup(const char *ptr) {
 #ifdef USE_TD_MEMORY
   if (ptr == NULL) return NULL;
 
   TdMemoryInfoPtr pTdMemoryInfo = (TdMemoryInfoPtr)((char *)ptr - sizeof(TdMemoryInfo));
   assert(pTdMemoryInfo->symbol == TD_MEMORY_SYMBOL);
 
-  void *tmp = tstrdup((const char *)pTdMemoryInfo);
+  void *tmp = tstrdup(pTdMemoryInfo);
   if (tmp == NULL) return NULL;
 
   memcpy(tmp, pTdMemoryInfo, sizeof(TdMemoryInfo));
@@ -297,7 +297,7 @@ void *taosMemoryStrDup(void *ptr) {
 
   return (char *)tmp + sizeof(TdMemoryInfo);
 #else
-  return tstrdup((const char *)ptr);
+  return tstrdup(ptr);
 #endif
 }
 
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index 9cd1294c17..0301b842c4 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -395,6 +395,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_DROPPING,            "Task dropping")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_DUPLICATTED_OPERATION,    "Duplicatted operation")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_MSG_ERROR,           "Task message error")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JOB_FREED,                "Job already freed")
+TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JOB_NOT_EXIST,            "Job not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_STATUS_ERROR,        "Task status error")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_IN_ERROR,            "Json not support in in/notin operator")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR,   "Json not support in this place")
diff --git a/tests/pytest/util/gettime.py b/tests/pytest/util/gettime.py
new file mode 100644
index 0000000000..94eed38478
--- /dev/null
+++ b/tests/pytest/util/gettime.py
@@ -0,0 +1,62 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import time
+from datetime import datetime
+
+class GetTime:
+
+    def get_ms_timestamp(self,ts_str):
+        _ts_str = ts_str
+        if " " in ts_str:
+            p = ts_str.split(" ")[1]
+            if len(p) > 15 :
+                _ts_str = ts_str[:-3]
+        if ':' in _ts_str and '.' in _ts_str:
+            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d %H:%M:%S.%f")
+            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
+        elif ':' in _ts_str and '.' not in _ts_str:
+            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d %H:%M:%S")
+            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
+        else:
+            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d")
+            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
+        return date_time
+    def get_us_timestamp(self,ts_str):
+        _ts = self.get_ms_timestamp(ts_str) * 1000
+        if " " in ts_str:
+            p = ts_str.split(" ")[1]
+            if len(p) > 12:
+                us_ts = p[12:15]
+                _ts += int(us_ts)
+        return _ts
+    def get_ns_timestamp(self,ts_str):
+        _ts = self.get_us_timestamp(ts_str) *1000
+        if " " in ts_str:
+            p = ts_str.split(" ")[1]
+            if len(p) > 15:
+                us_ts = p[15:]
+                _ts += int(us_ts)
+        return _ts
+    def time_transform(self,ts_str,precision):
+        date_time = []
+        if precision == 'ms':
+            for i in ts_str:
+                date_time.append(self.get_ms_timestamp(i))
+        elif precision == 'us':
+            for i in ts_str:
+                date_time.append(self.get_us_timestamp(i))
+        elif precision == 'ns':
+            for i in ts_str:
+                date_time.append(self.get_ns_timestamp(i))
+        return date_time
\ No newline at end of file
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index abf2ecf495..4e009e702d 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -167,7 +167,8 @@
 #./test.sh -f tsim/sma/rsmaPersistenceRecovery.sim
 
 # --- valgrind
-./test.sh -f tsim/valgrind/checkError.sim -v
+./test.sh -f tsim/valgrind/checkError1.sim
+./test.sh -f tsim/valgrind/checkError2.sim
 
 # --- vnode
 # ./test.sh -f tsim/vnode/replica3_basic.sim
diff --git a/tests/script/sh/checkValgrind.sh b/tests/script/sh/checkValgrind.sh
index e3afb10752..fdbac45ea6 100755
--- a/tests/script/sh/checkValgrind.sh
+++ b/tests/script/sh/checkValgrind.sh
@@ -4,13 +4,17 @@ set +e
 #set -x
 
 NODE_NAME=
+DETAIL=0
 
-while getopts "n:" arg
+while getopts "n:d" arg
 do
   case $arg in
     n)
       NODE_NAME=$OPTARG
       ;;
+    d)
+      DETAIL=1
+      ;;
     ?)
       echo "unkown argument"
       ;;
@@ -30,10 +34,26 @@ fi
 
 TAOS_DIR=`pwd`
 LOG_DIR=$TAOS_DIR/sim/$NODE_NAME/log
-#CFG_DIR=$TAOS_DIR/sim/$NODE_NAME/cfg
 
-#echo ---- $LOG_DIR
+error_summary=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "ERROR SUMMARY:" | awk '{print $4}' | awk '{sum+=$1}END{print sum}'`
+still_reachable=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "still reachable in" | wc -l`
+definitely_lost=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "definitely lost in" | wc -l`
+indirectly_lost=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "indirectly lost in " | wc -l`
+possibly_lost=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "possibly lost in " | wc -l`
+invalid_read=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "Invalid read of " | wc -l`
+invalid_write=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "Invalid write of " | wc -l`
+invalid_free=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "Invalid free() " | wc -l`
 
-#errors=`grep "ERROR SUMMARY:" ${LOG_DIR}/valgrind-taosd-*.log | cut -d ' ' -f 2,3,4,5 | tr -d "\n"`
-errors=`cat ${LOG_DIR}/valgrind-taosd-*.log | grep "ERROR SUMMARY:" | awk '{print $4}' | awk '{sum+=$1}END{print sum}'`
+if [ $DETAIL -eq 1 ]; then
+  echo error_summary: $error_summary
+  echo still_reachable: $still_reachable
+  echo definitely_lost: $definitely_lost
+  echo indirectly_lost: $indirectly_lost
+  echo possibly_lost: $possibly_lost
+  echo invalid_read: $invalid_read
+  echo invalid_write: $invalid_write
+  echo invalid_free: $invalid_free
+fi
+
+let "errors=$error_summary+$still_reachable+$definitely_lost+$indirectly_lost+$possibly_lost+$invalid_read+$invalid_write+$invalid_free"
 echo $errors
diff --git a/tests/script/tsim/valgrind/basic.sim b/tests/script/tsim/valgrind/basic1.sim
similarity index 59%
rename from tests/script/tsim/valgrind/basic.sim
rename to tests/script/tsim/valgrind/basic1.sim
index fe7b6973d4..c599263b5a 100644
--- a/tests/script/tsim/valgrind/basic.sim
+++ b/tests/script/tsim/valgrind/basic1.sim
@@ -9,17 +9,15 @@ step1:
 	$x = $x + 1
 	sleep 1000
 	if $x == 10 then
-	  print ====> dnode not ready!
+	  print ----> dnode not ready!
 		return -1
 	endi
 sql show dnodes
-print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ----> $data00 $data01 $data02 $data03 $data04 $data05
 if $rows != 1 then
   return -1
 endi
 
-goto _OVER
-
 print =============== step2: create alter drop show user
 sql create user u1 pass 'taosdata'
 sql show users
@@ -29,5 +27,17 @@ sql alter user u1 pass 'taosdata'
 sql drop user u1
 sql_error alter user u2 sysinfo 0
 
+print =============== step3: create drop dnode
+sql create dnode $hostname port 7200
+sql drop dnode 2
+sql alter dnode 1 'debugflag 143'
+
+print =============== step4: create alter drop show database
+sql create database db vgroups 1
+sql show databases
+sql show db.vgroups
+sql drop database db
+sql show databases
+
 _OVER:
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/tsim/valgrind/basic2.sim b/tests/script/tsim/valgrind/basic2.sim
index 440873b89b..ab25b7e0b7 100644
--- a/tests/script/tsim/valgrind/basic2.sim
+++ b/tests/script/tsim/valgrind/basic2.sim
@@ -9,11 +9,11 @@ step1:
 	$x = $x + 1
 	sleep 1000
 	if $x == 10 then
-	  print ====> dnode not ready!
+	  print ----> dnode not ready!
 		return -1
 	endi
 sql show dnodes
-print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ----> $data00 $data01 $data02 $data03 $data04 $data05
 if $rows != 1 then
   return -1
 endi
diff --git a/tests/script/tsim/valgrind/checkError.sim b/tests/script/tsim/valgrind/checkError.sim
deleted file mode 100644
index 8798f80cd0..0000000000
--- a/tests/script/tsim/valgrind/checkError.sim
+++ /dev/null
@@ -1,91 +0,0 @@
-system sh/stop_dnodes.sh
-system sh/deploy.sh -n dnode1 -i 1
-#system sh/deploy.sh -n dnode2 -i 2
-#system sh/deploy.sh -n dnode3 -i 3
-#system sh/deploy.sh -n dnode4 -i 4
-#system sh/cfg.sh -n dnode1 -c supportVnodes -v 0
-system sh/exec.sh -n dnode1 -s start
-#system sh/exec.sh -n dnode2 -s start
-#system sh/exec.sh -n dnode3 -s start
-#system sh/exec.sh -n dnode4 -s start
-
-sleep 2000
-
-#$loop_cnt = 0
-#check_dnode_ready:
-#	$loop_cnt = $loop_cnt + 1
-#	sleep 200
-#	if $loop_cnt == 10 then
-#	  print ====> dnode not ready!
-#		return -1
-#	endi
-#sql show dnodes
-#print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
-#print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6]
-#print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6]
-#print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6]
-#if $data[0][0] != 1 then
-#  return -1
-#endi
-#if $data[0][4] != ready then
-#  goto check_dnode_ready
-#endi
-#
-##sql connect
-#sql create dnode $hostname port 7200
-#sql create dnode $hostname port 7300
-#sql create dnode $hostname port 7400
-#
-#$loop_cnt = 0
-#check_dnode_ready_1:
-#$loop_cnt = $loop_cnt + 1
-#sleep 200
-#if $loop_cnt == 10 then
-#  print ====> dnodes not ready!
-#	return -1
-#endi
-#sql show dnodes
-#print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
-#print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6]
-#print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6]
-#print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6]
-#if $data[0][4] != ready then
-#  goto check_dnode_ready_1
-#endi
-#if $data[1][4] != ready then
-#  goto check_dnode_ready_1
-#endi
-#if $data[2][4] != ready then
-#  goto check_dnode_ready_1
-#endi
-#if $data[3][4] != ready then
-#  goto check_dnode_ready_1
-#endi
-
-#=========== please add any actions above =================
-
-print ====> stop all dondes to output valgrind log file
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
-
-print ====> start to check if there are ERRORS in vagrind log file for each dnode
-# -n : dnode[x] be check
-system_content sh/checkValgrind.sh -n dnode1 
-print cmd return result----> [ $system_content ]
-# temporarily expand the threshold, since no time to fix the memory leaks.
-if $system_content <= 5 then
-  return 0
-endi 
-
-# This error occurs frequently, allowing it
-# ==435850== 46 bytes in 1 blocks are definitely lost in loss record 1 of 3
-# ==435850==    at 0x483DD99: calloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgp    reload_memcheck-amd64-linux.so)
-# ==435850==    by 0x414AE0: taosMemoryCalloc (osMemory.c:212)
-# ==435850==    by 0x352730: transAllocBuffer (transComm.c:123)
-# ==435850==    by 0x34F42A: cliAllocRecvBufferCb (transCli.c:485)
-
-$null=
-if $system_content == $null then
-  return 0
-endi 
-
-return -1
diff --git a/tests/script/tsim/valgrind/checkError1.sim b/tests/script/tsim/valgrind/checkError1.sim
new file mode 100644
index 0000000000..10c9cb5d6f
--- /dev/null
+++ b/tests/script/tsim/valgrind/checkError1.sim
@@ -0,0 +1,50 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start -v
+sql connect
+
+print =============== step1: show dnodes
+
+$x = 0
+step1:
+	$x = $x + 1
+	sleep 1000
+	if $x == 10 then
+	  print ----> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ----> $data00 $data01 $data02 $data03 $data04 $data05
+if $rows != 1 then
+  return -1
+endi
+
+print =============== step2: create alter drop show user
+sql create user u1 pass 'taosdata'
+sql show users
+sql alter user u1 sysinfo 1
+sql alter user u1 enable 1
+sql alter user u1 pass 'taosdata'
+sql drop user u1
+sql_error alter user u2 sysinfo 0
+
+print =============== step3: 
+
+print =============== stop
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+print =============== check
+print ----> start to check if there are ERRORS in vagrind log file for each dnode
+system_content sh/checkValgrind.sh -n dnode1 
+
+print cmd return result ----> [ $system_content ]
+if $system_content <= 40 then
+  return 0
+endi 
+
+$null=
+if $system_content == $null then
+  return 0
+endi 
+
+return -1
diff --git a/tests/script/tsim/valgrind/checkError2.sim b/tests/script/tsim/valgrind/checkError2.sim
new file mode 100644
index 0000000000..cfc502bf3e
--- /dev/null
+++ b/tests/script/tsim/valgrind/checkError2.sim
@@ -0,0 +1,41 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start -v
+sql connect
+
+print =============== step1: create drop show dnodes
+$x = 0
+step1:
+	$x = $x + 1
+	sleep 1000
+	if $x == 10 then
+	  print ----> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ----> $data00 $data01 $data02 $data03 $data04 $data05
+if $rows != 1 then
+  return -1
+endi
+
+print =============== step2: create db
+sql create database db vgroups 1
+
+_OVER:
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+print =============== check
+print ----> start to check if there are ERRORS in vagrind log file for each dnode
+system_content sh/checkValgrind.sh -n dnode1 
+
+print cmd return result ----> [ $system_content ]
+if $system_content <= 60 then
+  return 0
+endi 
+
+$null=
+if $system_content == $null then
+  return 0
+endi 
+
+return -1
diff --git a/tests/system-test/0-others/udfTest.py b/tests/system-test/0-others/udfTest.py
index 40f803432a..ddbbd9b2de 100644
--- a/tests/system-test/0-others/udfTest.py
+++ b/tests/system-test/0-others/udfTest.py
@@ -313,11 +313,11 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.query("select udf1(num1) , bottom(num1,1) from tb;")
         tdSql.checkRows(1)
-        tdSql.query("select udf1(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
-        tdSql.query("select round(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select round(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
 
         # stable
@@ -342,10 +342,10 @@ class TDTestCase:
         tdSql.query("select ceil(c1) , bottom(c1,1) from stb1;")
         tdSql.checkRows(1)
 
-        tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
-        tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
+        # tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
 
         # regular table with compute functions
 
diff --git a/tests/system-test/0-others/udf_create.py b/tests/system-test/0-others/udf_create.py
index 63650d6edc..e53ed651f0 100644
--- a/tests/system-test/0-others/udf_create.py
+++ b/tests/system-test/0-others/udf_create.py
@@ -315,11 +315,11 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.query("select udf1(num1) , bottom(num1,1) from tb;")
         tdSql.checkRows(1)
-        tdSql.query("select udf1(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
-        tdSql.query("select round(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select round(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
 
         # stable
@@ -344,10 +344,10 @@ class TDTestCase:
         tdSql.query("select ceil(c1) , bottom(c1,1) from stb1;")
         tdSql.checkRows(1)
 
-        tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
-        tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
+        # tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
 
         # regular table with compute functions
 
diff --git a/tests/system-test/0-others/udf_restart_taosd.py b/tests/system-test/0-others/udf_restart_taosd.py
index c318980b67..b860a0dfab 100644
--- a/tests/system-test/0-others/udf_restart_taosd.py
+++ b/tests/system-test/0-others/udf_restart_taosd.py
@@ -312,11 +312,11 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.query("select udf1(num1) , bottom(num1,1) from tb;")
         tdSql.checkRows(1)
-        tdSql.query("select udf1(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
-        tdSql.query("select round(num1) , last_row(num1) from tb;")
-        tdSql.checkRows(1)
+        # tdSql.query("select round(num1) , last_row(num1) from tb;")
+        # tdSql.checkRows(1)
 
 
         # stable
@@ -341,10 +341,10 @@ class TDTestCase:
         tdSql.query("select ceil(c1) , bottom(c1,1) from stb1;")
         tdSql.checkRows(1)
 
-        tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
-        tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
-        tdSql.checkRows(1)
+        # tdSql.query("select udf1(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
+        # tdSql.query("select ceil(c1) , last_row(c1) from stb1;")
+        # tdSql.checkRows(1)
 
         # regular table with compute functions
 
diff --git a/tests/system-test/1-insert/alter_stable.py b/tests/system-test/1-insert/alter_stable.py
index a4cec78138..b66cbb89c0 100644
--- a/tests/system-test/1-insert/alter_stable.py
+++ b/tests/system-test/1-insert/alter_stable.py
@@ -108,8 +108,8 @@ class TDTestCase:
                 tdSql.error(f'alter stable {self.stbname}_{i} add column {key} {values}')
                 tdSql.error(f'alter stable {self.stbname}_{i} drop column {key}')
             #! bug TD-16921
-            #tdSql.error(f'alter stable {self.ntbname} add column {key} {values}')
-            #tdSql.error(f'alter stable {self.ntbname} drop column {key}')
+            tdSql.error(f'alter stable {self.ntbname} add column {key} {values}')
+            tdSql.error(f'alter stable {self.ntbname} drop column {key}')
             tdSql.execute(f'alter stable {self.stbname} drop column {key}')
             tdSql.query(f'describe {self.stbname}')
             tdSql.checkRows(len(self.column_dict)+len(self.tag_dict))
@@ -132,7 +132,7 @@ class TDTestCase:
                     tdSql.checkEqual(result[0][2],self.binary_length+1)
                     tdSql.error(f'alter stable {self.stbname}_{i} modify column {key} {v}')
                #! bug TD-16921
-               # tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
+                tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
             elif 'nchar' in values.lower():
                 v = f'nchar({self.binary_length+1})'
                 v_error = f'nchar({self.binary_length-1})'
@@ -147,11 +147,11 @@ class TDTestCase:
                     tdSql.checkEqual(result[0][2],self.binary_length+1)
                     tdSql.error(f'alter stable {self.stbname}_{i} modify column {key} {v}')
                 #! bug TD-16921
-                #tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
+                tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
             else:
                 for v in self.column_dict.values():
                     tdSql.error(f'alter stable {self.stbname} modify column {key} {v}')
-                   # tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
+                    tdSql.error(f'alter stable {self.ntbname} modify column {key} {v}')
                     for i in range(self.tbnum):
                         tdSql.error(f'alter stable {self.stbname}_{i} modify column {key} {v}')
     def run(self):
diff --git a/tests/system-test/1-insert/test_stmt_muti_insert_query.py b/tests/system-test/1-insert/test_stmt_muti_insert_query.py
index de10b2f6b9..9fb802b96b 100644
--- a/tests/system-test/1-insert/test_stmt_muti_insert_query.py
+++ b/tests/system-test/1-insert/test_stmt_muti_insert_query.py
@@ -96,7 +96,7 @@ class TDTestCase:
                 ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
             )
             # conn.load_table_info("log")
-
+            tdLog.debug("statement start")
             start = datetime.now()
             stmt = conn.statement("insert into stb1 values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
 
@@ -118,8 +118,11 @@ class TDTestCase:
             params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
             params[15].timestamp([None, None, 1626861392591])
             # print(type(stmt))
+            tdLog.debug("bind_param_batch start")
             stmt.bind_param_batch(params)
+            tdLog.debug("bind_param_batch end")
             stmt.execute()
+            tdLog.debug("execute end")
             end = datetime.now()
             print("elapsed time: ", end - start)
             assert stmt.affected_rows == 3
@@ -155,7 +158,7 @@ class TDTestCase:
             print(rows1)
             assert str(rows1[0][0]) == "2021-07-21 17:56:32.589000"
             assert rows1[0][10] == 3
-
+            tdLog.debug("close start")
 
             stmt.close()
 
diff --git a/tests/system-test/2-query/Timediff.py b/tests/system-test/2-query/Timediff.py
index b8f3649eff..70cf34e766 100644
--- a/tests/system-test/2-query/Timediff.py
+++ b/tests/system-test/2-query/Timediff.py
@@ -1,202 +1,171 @@
 from util.log import *
 from util.sql import *
 from util.cases import *
-
+from util.gettime import *
 class TDTestCase:
 
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
+        self.get_time = GetTime()
+        self.ts_str = [
+            '2020-1-1',
+            '2020-2-1 00:00:01',
+            '2020-3-1 00:00:00.001',
+            '2020-4-1 00:00:00.001002',
+            '2020-5-1 00:00:00.001002001'
 
+        ]
+        self.db_param_precision = ['ms','us','ns']
+        self.time_unit = ['1w','1d','1h','1m','1s','1a','1u','1b']
+        self.error_unit = ['2w','2d','2h','2m','2s','2a','2u','1c','#1']
+        self.ntbname = 'ntb'
+        self.stbname = 'stb'
+        self.ctbname = 'ctb'
+        self.subtractor = 1  # unit:s
+    def check_tbtype(self,tb_type):
+        if tb_type.lower() == 'ntb': 
+            tdSql.query(f'select timediff(ts,{self.subtractor}) from {self.ntbname}')
+        elif tb_type.lower() == 'ctb':
+            tdSql.query(f'select timediff(ts,{self.subtractor}) from {self.ctbname}')
+        elif tb_type.lower() == 'stb':
+            tdSql.query(f'select timediff(ts,{self.subtractor}) from {self.stbname}')
+    def check_tb_type(self,unit,tb_type):
+        if tb_type.lower() == 'ntb': 
+            tdSql.query(f'select timediff(ts,{self.subtractor},{unit}) from {self.ntbname}')
+        elif tb_type.lower() == 'ctb':
+            tdSql.query(f'select timediff(ts,{self.subtractor},{unit}) from {self.ctbname}')
+        elif tb_type.lower() == 'stb':
+            tdSql.query(f'select timediff(ts,{self.subtractor},{unit}) from {self.stbname}')
+    def data_check(self,date_time,precision,tb_type):
+        for unit in self.time_unit:
+            if (unit.lower() == '1u' and precision.lower() == 'ms') or (unit.lower() == '1b' and precision.lower() == 'us') or (unit.lower() == '1b' and precision.lower() == 'ms'):
+                if tb_type.lower() == 'ntb': 
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ntbname}')
+                elif tb_type.lower() == 'ctb':
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ctbname}')
+                elif tb_type.lower() == 'stb':
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.stbname}')
+            elif precision.lower() == 'ms':
+                self.check_tb_type(unit,tb_type)
+                tdSql.checkRows(len(self.ts_str))
+                if unit.lower() == '1a':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i])-self.subtractor*1000)
+                elif unit.lower() == '1s':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]/1000)-self.subtractor)
+                elif unit.lower() == '1m':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor)/60))
+                elif unit.lower() == '1h':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor)/60/60))
+                elif unit.lower() == '1d':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor)/60/60/24))        
+                elif unit.lower() == '1w':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor)/60/60/24/7))
+                self.check_tbtype(tb_type)
+                tdSql.checkRows(len(self.ts_str))
+                for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i])-self.subtractor*1000)
+            elif precision.lower() == 'us':
+                self.check_tb_type(unit,tb_type)
+                tdSql.checkRows(len(self.ts_str))
+                if unit.lower() == '1w':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor)/60/60/24/7))
+                elif unit.lower() == '1d':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor)/60/60/24))
+                elif unit.lower() == '1h':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor)/60/60))
+                elif unit.lower() == '1m':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor)/60))
+                elif unit.lower() == '1s':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor)))
+                elif unit.lower() == '1a':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor*1000)))
+                elif unit.lower() == '1u':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000)))        
+                self.check_tbtype(tb_type)
+                tdSql.checkRows(len(self.ts_str))
+                for i in range(len(self.ts_str)):
+                    tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000)))
+            elif precision.lower() == 'ns':
+                self.check_tb_type(unit,tb_type)
+                tdSql.checkRows(len(self.ts_str))
+                if unit.lower() == '1w':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24/7))
+                elif unit.lower() == '1d':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24))
+                elif unit.lower() == '1h':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60))
+                elif unit.lower() == '1m':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60))
+                elif unit.lower() == '1s':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)))
+                elif unit.lower() == '1a':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor*1000)))
+                elif unit.lower() == '1u':
+                    for i in range(len(self.ts_str)):
+                        tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor*1000000)))
+                # self.check_tbtype(tb_type)
+                # tdSql.checkRows(len(self.ts_str))
+                # for i in range(len(self.ts_str)):
+                #     tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor*1000000000)))
+            for unit in self.error_unit:
+                if tb_type.lower() == 'ntb':
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ntbname}')
+                    tdSql.error(f'select timediff(c0,{self.subtractor},{unit}) from {self.ntbname}')
+                elif tb_type.lower() == 'ctb':
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ctbname}')
+                    tdSql.error(f'select timediff(c0,{self.subtractor},{unit}) from {self.ntbname}')
+                elif tb_type.lower() == 'stb':
+                    tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.stbname}')
+                    tdSql.error(f'select timediff(c0,{self.subtractor},{unit}) from {self.ntbname}')
+    def function_check_ntb(self):
+        for precision in self.db_param_precision:
+            tdSql.execute('drop database if exists db')
+            tdSql.execute(f'create database db precision "{precision}"')
+            tdSql.execute('use db')
+            tdSql.execute(f'create table {self.ntbname} (ts timestamp,c0 int)')
+            for ts in self.ts_str:
+                tdSql.execute(f'insert into {self.ntbname} values("{ts}",1)')
+            for unit in self.error_unit:
+                tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ntbname}')
+            date_time = self.get_time.time_transform(self.ts_str,precision)
+            self.data_check(date_time,precision,'ntb')
+    def function_check_stb(self):
+        for precision in self.db_param_precision:
+            tdSql.execute('drop database if exists db')
+            tdSql.execute(f'create database db precision "{precision}"')
+            tdSql.execute('use db')
+            tdSql.execute(f'create table {self.stbname} (ts timestamp,c0 int) tags(t0 int)')
+            tdSql.execute(f'create table {self.ctbname} using {self.stbname} tags(1)')
+            for ts in self.ts_str:
+                tdSql.execute(f'insert into {self.ctbname} values("{ts}",1)')
+            date_time = self.get_time.time_transform(self.ts_str,precision)
+            self.data_check(date_time,precision,'ctb')
+            self.data_check(date_time,precision,'stb')
     def run(self):  # sourcery skip: extract-duplicate-method
-        tdSql.prepare()
-        tdLog.printNoPrefix("==========step1:create tables==========")
-        tdSql.execute(
-            '''create table if not exists ntb
-            (ts timestamp, c1 int, c2 float,c3 double,c4 timestamp)
-            '''
-        )
-        tdSql.execute(
-            '''create table if not exists stb
-            (ts timestamp, c1 int, c2 float,c3 double,c4 timestamp) tags(t0 int)
-            '''
-        )
-        tdSql.execute(
-            '''create table if not exists stb_1 using stb tags(100)
-            '''
-        )
-        tdLog.printNoPrefix("==========step2:insert data into ntb==========")
-
-        # RFC3339:2020-01-01T00:00:00+8:00
-        # ISO8601:2020-01-01T00:00:00.000+0800
-        tdSql.execute(
-            'insert into ntb values(now,1,1.55,100.555555,today())("2020-1-1 00:00:00",10,11.11,99.999999,now())(today(),3,3.333,333.333333,now())')
-        tdSql.execute(
-            'insert into stb_1 values(now,1,1.55,100.555555,today())("2020-1-1 00:00:00",10,11.11,99.999999,now())(today(),3,3.333,333.333333,now())')
-
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00') from ntb")
-        tdSql.checkRows(3)
-        tdSql.query("select timediff(1,0,1d) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1d) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1s) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1)
-        tdSql.query("select timediff(1,0,1s) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1)
-        tdSql.query("select timediff(1,0,1w) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1w) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1h) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1h) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1m) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1m) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff(1,0,1a) from ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1000)
-        tdSql.query("select timediff(1,0,1a) from db.ntb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1000)
-        tdSql.error("select timediff(1,0,1u) from ntb")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,1000000)
-        tdSql.error("select timediff(1,0,1u) from db.ntb")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,1000000)
-
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00') from stb")
-        tdSql.checkRows(3)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00') from db.stb")
-        tdSql.checkRows(3)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1d) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1d) from db.stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1h) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,24)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1h) from db.stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,24)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1w) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1m) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1440)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1m) from db.stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,1440)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1s) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,86400)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1s) from db.stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,86400)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1a) from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,86400000)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1a) from db.stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,86400000)
-        tdSql.error("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1u) from stb")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,86400000000)
-        tdSql.error("select timediff('2020-1-1 00:00:00','2020-1-2 00:00:00',1u) from db.stb")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,86400000000)
-
-
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00') from stb_1")
-        tdSql.checkRows(3)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00') from db.stb_1")
-        tdSql.checkRows(3)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1w) from stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1w) from db.stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1d) from stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1d) from db.stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,0)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1h) from stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,12)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1h) from db.stb_1 ")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,12)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1m) from stb_1" )
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,720)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1m) from db.stb_1" )
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,720)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1s) from stb_1")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,43200)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1s) from db.stb_1")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,43200)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1a) from stb_1")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,43200000)
-        tdSql.query("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1a) from db.stb_1")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,43200000)
-        tdSql.error("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1u) from stb_1")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,43200000000)
-        tdSql.error("select timediff('2020-1-1 00:00:00','2020-1-1 12:00:00',1u) from db.stb_1")
-        #tdSql.checkRows(3)
-        #tdSql.checkData(0,0,43200000000)
-
-        tdSql.query("select timediff('a','b') from stb")
-        tdSql.checkRows(3)
-        tdSql.checkData(0,0,None)
-        tdSql.checkData(1,0,None)
-        tdSql.checkData(2,0,None)
-        tdSql.error("select timediff(1.5,1.5) from stb")
-        tdSql.error("select timediff(1) from stb")
-        tdSql.error("select timediff(10,1,1.5) from stb")
-        # tdSql.error("select timediff(10,1,2s) from stb")
-        # tdSql.error("select timedifff(10,1,c1) from stb")
-        tdSql.error("select timediff(1.5,1.5) from stb_1")
-        tdSql.error("select timediff(1) from stb_1")
-        tdSql.error("select timediff(10,1,1.5) from stb_1")
-        # tdSql.error("select timediff(10,1,2s) from stb_1")
-        # tdSql.error("select timedifff(10,1,c1) from stb_1")
-        tdSql.error("select timediff(1.5,1.5) from ntb")
-        tdSql.error("select timediff(1) from ntb")
-        tdSql.error("select timediff(10,1,1.5) from ntb")
-        # tdSql.error("select timediff(10,1,2s) from ntb")
-        # tdSql.error("select timedifff(10,1,c1) from ntb")
-
-
-
-
-
 
+        self.function_check_ntb()
+        self.function_check_stb()
+        
     def stop(self):
         tdSql.close()
         tdLog.success(f"{__file__} successfully executed")
diff --git a/tests/system-test/2-query/distribute_agg_stddev.py b/tests/system-test/2-query/distribute_agg_stddev.py
index 59ede38983..09a6b86d34 100644
--- a/tests/system-test/2-query/distribute_agg_stddev.py
+++ b/tests/system-test/2-query/distribute_agg_stddev.py
@@ -7,7 +7,7 @@ import platform
 import math
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"fnDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -24,7 +24,7 @@ class TDTestCase:
         stddev_sql = f"select stddev({col_name}) from {tbname};"
 
         same_sql = f"select {col_name} from {tbname} where {col_name} is not null "
-   
+
         tdSql.query(same_sql)
         pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
         if (platform.system().lower() == 'windows' and pre_data.dtype == 'int32'):
@@ -32,21 +32,21 @@ class TDTestCase:
         pre_avg = np.sum(pre_data)/len(pre_data)
 
         # Calculate variance
-        stddev_result = 0 
+        stddev_result = 0
         for num in tdSql.queryResult:
             stddev_result += (num-pre_avg)*(num-pre_avg)/len(tdSql.queryResult)
 
         stddev_result = math.sqrt(stddev_result)
 
         tdSql.query(stddev_sql)
-        
+
         if -0.0001 < tdSql.queryResult[0][0]-stddev_result < 0.0001:
             tdLog.info(" sql:%s; row:0 col:0 data:%d , expect:%d"%(stddev_sql,tdSql.queryResult[0][0],stddev_result))
         else:
             tdLog.exit(" sql:%s; row:0 col:0 data:%d , expect:%d"%(stddev_sql,tdSql.queryResult[0][0],stddev_result))
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -117,17 +117,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -138,14 +138,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_stddev_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -154,7 +154,7 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         stddev_sql = f"select stddev({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select {col_name}  from stb1 where tbname in ({tbname_filters}) and {col_name} is not null "
@@ -166,7 +166,7 @@ class TDTestCase:
         pre_avg = np.sum(pre_data)/len(pre_data)
 
         # Calculate variance
-        stddev_result = 0 
+        stddev_result = 0
         for num in tdSql.queryResult:
             stddev_result += (num-pre_avg)*(num-pre_avg)/len(tdSql.queryResult)
 
@@ -177,8 +177,8 @@ class TDTestCase:
 
 
     def check_stddev_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -187,31 +187,31 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 if colname.startswith("c"):
                     self.check_stddev_functions(tablename,colname)
                 else:
-                    # self.check_stddev_functions(tablename,colname) 
+                    # self.check_stddev_functions(tablename,colname)
                     pass
 
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_stddev_distribute_diff_vnode(colname)
             else:
-                # self.check_stddev_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_stddev_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query(" select stddev(c1) from stb1 ")
@@ -235,7 +235,7 @@ class TDTestCase:
         tdSql.query("select stddev(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select stddev(c1) from stb1 union all select stddev(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,6.694663959)
@@ -244,7 +244,7 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.checkData(0,0,0.000000000)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -252,7 +252,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -263,7 +263,7 @@ class TDTestCase:
         tdSql.checkData(0,0,2.872281323)
         tdSql.checkData(0,1,2.872281323)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
 
         # partition by tbname or partition by tag
@@ -295,7 +295,7 @@ class TDTestCase:
         self.check_stddev_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/system-test/2-query/json_tag.py b/tests/system-test/2-query/json_tag.py
index 9e48f7d45a..81098159f2 100644
--- a/tests/system-test/2-query/json_tag.py
+++ b/tests/system-test/2-query/json_tag.py
@@ -543,9 +543,9 @@ class TDTestCase:
         tdSql.checkData(0, 0, 10)
         tdSql.query("select avg(dataint) from jsons1 where jtag is not null")
         tdSql.checkData(0, 0, 5.3)
-        tdSql.query("select twa(dataint) from jsons1 where jtag is not null")
-        tdSql.checkData(0, 0, 28.386363636363637)
-        tdSql.query("select irate(dataint) from jsons1 where jtag is not null")
+        # tdSql.query("select twa(dataint) from jsons1 where jtag is not null")
+        # tdSql.checkData(0, 0, 28.386363636363637)
+        # tdSql.query("select irate(dataint) from jsons1 where jtag is not null")
 
         tdSql.query("select sum(dataint) from jsons1 where jtag->'tag1' is not null")
         tdSql.checkData(0, 0, 45)
@@ -575,10 +575,10 @@ class TDTestCase:
         #test calculation function:diff/derivative/spread/ceil/floor/round/
         tdSql.query("select diff(dataint) from jsons1 where jtag->'tag1'>1")
         tdSql.checkRows(2)
-        tdSql.checkData(0, 0, -1)
-        tdSql.checkData(1, 0, 10)
+        # tdSql.checkData(0, 0, -1)
+        # tdSql.checkData(1, 0, 10)
         tdSql.query("select derivative(dataint, 10m, 0) from jsons1 where jtag->'tag1'>1")
-        tdSql.checkData(0, 0, -2)
+        # tdSql.checkData(0, 0, -2)
         tdSql.query("select spread(dataint) from jsons1 where jtag->'tag1'>1")
         tdSql.checkData(0, 0, 10)
         tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1")
diff --git a/tests/system-test/2-query/percentile.py b/tests/system-test/2-query/percentile.py
index 8df9bcb9ce..c2584fd394 100644
--- a/tests/system-test/2-query/percentile.py
+++ b/tests/system-test/2-query/percentile.py
@@ -21,7 +21,7 @@ import numpy as np
 class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor())
+        tdSql.init(conn.cursor(), True)
 
         self.rowNum = 10
         self.ts = 1537146000000
diff --git a/tests/system-test/2-query/timetruncate.py b/tests/system-test/2-query/timetruncate.py
index ebc8e6b6f9..ee302a1d8e 100644
--- a/tests/system-test/2-query/timetruncate.py
+++ b/tests/system-test/2-query/timetruncate.py
@@ -5,184 +5,131 @@ from util.sql import *
 import numpy as np
 import time
 from datetime import datetime
-
+from util.gettime import *
 class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
         tdSql.init(conn.cursor())
-
-        self.rowNum = 10
-        self.ts = 1537146000000  # 2018-9-17 09:00:00.000
-
+        self.get_time = GetTime()
         self.ts_str = [
             '2020-1-1',
             '2020-2-1 00:00:01',
             '2020-3-1 00:00:00.001',
             '2020-4-1 00:00:00.001002',
             '2020-5-1 00:00:00.001002001'
-
         ]
         self.db_param_precision = ['ms','us','ns']
-        self.time_unit = ['1w','1d','1h','1m','1s','1a','1u']
-        #self.error_unit = ['1b','2w','2d','2h','2m','2s','2a','2u','1c','#1']
+        self.time_unit = ['1w','1d','1h','1m','1s','1a','1u','1b']
+        self.error_unit = ['2w','2d','2h','2m','2s','2a','2u','1c','#1']
         self.error_unit = ['2w','2d','2h','2m','2s','2a','2u','1c','#1']
         self.ntbname = 'ntb'
         self.stbname = 'stb'
         self.ctbname = 'ctb'
-    def get_ms_timestamp(self,ts_str):
-        _ts_str = ts_str
-        if " " in ts_str:
-            p = ts_str.split(" ")[1]
-            if len(p) > 15 :
-                _ts_str = ts_str[:-3]
-        if ':' in _ts_str and '.' in _ts_str:
-            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d %H:%M:%S.%f")
-            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
-        elif ':' in _ts_str and '.' not in _ts_str:
-            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d %H:%M:%S")
-            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
-        else:
-            timestamp = datetime.strptime(_ts_str, "%Y-%m-%d")
-            date_time = int(int(time.mktime(timestamp.timetuple()))*1000 + timestamp.microsecond/1000)
-        return date_time
-    def get_us_timestamp(self,ts_str):
-        _ts = self.get_ms_timestamp(ts_str) * 1000
-        if " " in ts_str:
-            p = ts_str.split(" ")[1]
-            if len(p) > 12:
-                us_ts = p[12:15]
-                _ts += int(us_ts)
-        return _ts
-    def get_ns_timestamp(self,ts_str):
-        _ts = self.get_us_timestamp(ts_str) *1000
-        if " " in ts_str:
-            p = ts_str.split(" ")[1]
-            if len(p) > 15:
-                us_ts = p[15:]
-                _ts += int(us_ts)
-        return _ts
-    def time_transform(self,ts_str,precision):
-        date_time = []
-        if precision == 'ms':
-            for i in ts_str:
-                date_time.append(self.get_ms_timestamp(i))
-        elif precision == 'us':
-            for i in ts_str:
-                date_time.append(self.get_us_timestamp(i))
-        elif precision == 'ns':
-            for i in ts_str:
-                date_time.append(self.get_us_timestamp(i))
-        return date_time
     def check_ms_timestamp(self,unit,date_time):
         if unit.lower() == '1a':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]))
         elif unit.lower() == '1s':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000)*1000)
         elif unit.lower() == '1m':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/60)*60*1000)
         elif unit.lower() == '1h':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/60/60)*60*60*1000  )
         elif unit.lower() == '1d':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
-                tdSql.checkEqual(ts_result,int(date_time[i]/1000/60/60/24)*24*60*60*1000)
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                tdSql.checkEqual(ts_result,int(date_time[i]/1000/60/60/24)*24*60*60*1000)  
         elif unit.lower() == '1w':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_ms_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_ms_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/60/60/24/7)*7*24*60*60*1000)
     def check_us_timestamp(self,unit,date_time):
         if unit.lower() == '1u':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]))
         elif unit.lower() == '1a':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000)*1000)
         elif unit.lower() == '1s':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000)*1000*1000)
         elif unit.lower() == '1m':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000/60)*60*1000*1000)
         elif unit.lower() == '1h':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000/60/60)*60*60*1000*1000  )
         elif unit.lower() == '1d':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
-                tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000/60/60/24)*24*60*60*1000*1000 )
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000/60/60/24)*24*60*60*1000*1000 ) 
         elif unit.lower() == '1w':
             for i in range(len(self.ts_str)):
-                ts_result = self.get_us_timestamp(str(tdSql.queryResult[i][0]))
+                ts_result = self.get_time.get_us_timestamp(str(tdSql.queryResult[i][0]))
                 tdSql.checkEqual(ts_result,int(date_time[i]/1000/1000/60/60/24/7)*7*24*60*60*1000*1000)
     def check_ns_timestamp(self,unit,date_time):
-        if unit.lower() == '1u':
+        if unit.lower() == '1b':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000)*1000)
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]))
+        elif unit.lower() == '1u':
+            for i in range(len(self.ts_str)):
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000)*1000)
         elif unit.lower() == '1a':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000)*1000*1000)
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000)*1000*1000)
         elif unit.lower() == '1s':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000)*1000*1000*1000)
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/1000)*1000*1000*1000)
         elif unit.lower() == '1m':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/60)*60*1000*1000*1000)
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/1000/60)*60*1000*1000*1000)
         elif unit.lower() == '1h':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/60/60)*60*60*1000*1000*1000  )
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/1000/60/60)*60*60*1000*1000*1000  )
         elif unit.lower() == '1d':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/60/60/24)*24*60*60*1000*1000*1000 )
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/1000/60/60/24)*24*60*60*1000*1000*1000 ) 
         elif unit.lower() == '1w':
             for i in range(len(self.ts_str)):
-                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/60/60/24/7)*7*24*60*60*1000*1000*1000)
+                tdSql.checkEqual(tdSql.queryResult[i][0],int(date_time[i]*1000/1000/1000/1000/1000/60/60/24/7)*7*24*60*60*1000*1000*1000)
+    def check_tb_type(self,unit,tb_type):
+        if tb_type.lower() == 'ntb': 
+            tdSql.query(f'select timetruncate(ts,{unit}) from {self.ntbname}')
+        elif tb_type.lower() == 'ctb':
+            tdSql.query(f'select timetruncate(ts,{unit}) from {self.ctbname}')
+        elif tb_type.lower() == 'stb':
+            tdSql.query(f'select timetruncate(ts,{unit}) from {self.stbname}')
     def data_check(self,date_time,precision,tb_type):
         for unit in self.time_unit:
-            if (unit.lower() == '1u' and precision.lower() == 'ms') or () :
-                if tb_type.lower() == 'ntb':
+            if (unit.lower() == '1u' and precision.lower() == 'ms') or (unit.lower() == '1b' and precision.lower() == 'us') or (unit.lower() == '1b' and precision.lower() == 'ms'):
+                if tb_type.lower() == 'ntb': 
                     tdSql.error(f'select timetruncate(ts,{unit}) from {self.ntbname}')
                 elif tb_type.lower() == 'ctb':
                     tdSql.error(f'select timetruncate(ts,{unit}) from {self.ctbname}')
                 elif tb_type.lower() == 'stb':
                     tdSql.error(f'select timetruncate(ts,{unit}) from {self.stbname}')
             elif precision.lower() == 'ms':
-                if tb_type.lower() == 'ntb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ntbname}')
-                elif tb_type.lower() == 'ctb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ctbname}')
-                elif tb_type.lower() == 'stb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.stbname}')
+                self.check_tb_type(unit,tb_type)
                 tdSql.checkRows(len(self.ts_str))
                 self.check_ms_timestamp(unit,date_time)
             elif precision.lower() == 'us':
-                if tb_type.lower() == 'ntb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ntbname}')
-                elif tb_type.lower() == 'ctb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ctbname}')
-                elif tb_type.lower() == 'stb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.stbname}')
+                self.check_tb_type(unit,tb_type)
                 tdSql.checkRows(len(self.ts_str))
                 self.check_us_timestamp(unit,date_time)
             elif precision.lower() == 'ns':
-                if tb_type.lower() == 'ntb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ntbname}')
-                elif tb_type.lower() == 'ctb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.ctbname}')
-                elif tb_type.lower() == 'stb':
-                    tdSql.query(f'select timetruncate(ts,{unit}) from {self.stbname}')
+                self.check_tb_type(unit,tb_type)
                 tdSql.checkRows(len(self.ts_str))
                 self.check_ns_timestamp(unit,date_time)
         for unit in self.error_unit:
@@ -200,9 +147,8 @@ class TDTestCase:
             tdSql.execute(f'create table {self.ntbname} (ts timestamp,c0 int)')
             for ts in self.ts_str:
                 tdSql.execute(f'insert into {self.ntbname} values("{ts}",1)')
-            date_time = self.time_transform(self.ts_str,precision)
+            date_time = self.get_time.time_transform(self.ts_str,precision)
             self.data_check(date_time,precision,'ntb')
-
     def function_check_stb(self):
         for precision in self.db_param_precision:
             tdSql.execute('drop database if exists db')
@@ -212,7 +158,7 @@ class TDTestCase:
             tdSql.execute(f'create table {self.ctbname} using {self.stbname} tags(1)')
             for ts in self.ts_str:
                 tdSql.execute(f'insert into {self.ctbname} values("{ts}",1)')
-            date_time = self.time_transform(self.ts_str,precision)
+            date_time = self.get_time.time_transform(self.ts_str,precision)
             self.data_check(date_time,precision,'ctb')
             self.data_check(date_time,precision,'stb')
     def run(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
index fc2552d6f2..eaef134845 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
@@ -172,7 +172,7 @@ class TDTestCase:
         tmqCom.initConsumerTable()
         
         tdLog.info("create topics from stb with filter")
-        queryString = "select ts, acos(c1), ceil(pow(c1,3)) from %s.%s where (sin(c2) >= 0) and (c1 %% 4 == 0) and (ts >= %d) and (t4 like 'shanghai')"%(paraDict['dbName'], paraDict['stbName'], paraDict["startTs"]+math.ceil(self.rowsPerTbl/5))
+        queryString = "select ts, acos(c1), ceil(pow(c1,3)) from %s.%s where (sin(c2) >= 0) and (c1 %% 4 != 0) and (ts+1a >= %d) and (t4 like '%%shanghai')"%(paraDict['dbName'], paraDict['stbName'], paraDict["startTs"]+math.ceil(self.rowsPerTbl/10))
         # queryString = "select * from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
         # sqlString = "create topic %s as stable %s" %(topicNameList[0], paraDict['stbName'])
         sqlString = "create topic %s as %s" %(topicNameList[0], queryString)
diff --git a/tests/system-test/simpletest.bat b/tests/system-test/simpletest.bat
index b7e10f423b..e33fe0d538 100644
--- a/tests/system-test/simpletest.bat
+++ b/tests/system-test/simpletest.bat
@@ -1,5 +1,5 @@
 
-@REM python3 .\test.py -f 0-others\taosShell.py
+python3 .\test.py -f 0-others\taosShell.py
 python3 .\test.py -f 0-others\taosShellError.py
 python3 .\test.py -f 0-others\taosShellNetChk.py
 python3 .\test.py -f 0-others\telemetry.py