diff --git a/src/client/inc/tscDelete.h b/src/client/inc/tscDelete.h
new file mode 100644
index 0000000000000000000000000000000000000000..e94aeb2b8451bb95eb24e76988bff7166151a149
--- /dev/null
+++ b/src/client/inc/tscDelete.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_TSCDELETE_H
+#define TDENGINE_TSCDELETE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "qTableMeta.h"
+
+int32_t executeDelete(SSqlObj* pSql, SQueryInfo* pQueryInfo);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_TSCDELETE_H
diff --git a/src/client/inc/tscSubquery.h b/src/client/inc/tscSubquery.h
index 5293a176d85a0d928e3cf6211c31e301352ce2e7..1bd7d1f453866c00a3ed613e49244188c5a85fba 100644
--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -54,7 +54,8 @@ void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
 
 void tscFreeRetrieveSup(void **param);
 
-
+SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj, __async_cb_func_t fp, int32_t cmd);
+void doConcurrentlySendSubQueries(SSqlObj* pSql);
 
 #ifdef __cplusplus
 }
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 6bb124847bae2a21d6696d3cf2abb4961d29718f..3f65c64aed6b7fd4f9c0fb14336785934820246f 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -319,6 +319,7 @@ typedef struct {
 
   TAOS_FIELD*    final;
   struct SGlobalMerger *pMerger;
+  int32_t        numOfTables;
 } SSqlRes;
 
 typedef struct {
@@ -498,6 +499,7 @@ void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, __async_cb_func_t fp, void *para
 void tscImportDataFromFile(SSqlObj *pSql);
 struct SGlobalMerger* tscInitResObjForLocalQuery(int32_t numOfRes, int32_t rowLen, uint64_t id);
 bool tscIsUpdateQuery(SSqlObj* pSql);
+bool tscIsDeleteQuery(SSqlObj* pSql);
 char* tscGetSqlStr(SSqlObj* pSql);
 bool tscIsQueryWithLimit(SSqlObj* pSql);
 
diff --git a/src/client/src/tscDelete.c b/src/client/src/tscDelete.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5d044d9dba7d98763666ee6bde7ba5de4d41ba3
--- /dev/null
+++ b/src/client/src/tscDelete.c
@@ -0,0 +1,253 @@
+/*
+ * 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 "os.h"
+#include "taosmsg.h"
+#include "tcmdtype.h"
+#include "tscLog.h"
+#include "tscUtil.h"
+#include "tsclient.h"
+#include "tscDelete.h"
+#include "tscSubquery.h"
+
+
+void tscDumpEpSetFromVgroupInfo(SRpcEpSet *pEpSet, SNewVgroupInfo *pVgroupInfo);
+
+//
+// handle error
+//
+void tscHandleSubDeleteError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numOfRows) {
+
+}
+
+//
+// sub delete sql callback
+//
+void tscSubDeleteCallback(void *param, TAOS_RES *tres, int code) {
+  // the param may be null, since it may be done by other query threads. and the asyncOnError may enter in this
+  // function while kill query by a user.
+  if (param == NULL) {
+    assert(code != TSDB_CODE_SUCCESS);
+    return;
+  }
+
+  SRetrieveSupport *trsupport = (SRetrieveSupport *) param;
+  
+  SSqlObj*  pParentSql = trsupport->pParentSql;
+  SSqlObj*  pSql       = (SSqlObj *) tres;
+  
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentSql->cmd, 0);
+  SVgroupMsg* pVgroup = &pTableMetaInfo->vgroupList->vgroups[trsupport->subqueryIndex];
+
+  //
+  // stable query killed or other subquery failed, all query stopped
+  //
+  if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
+    trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
+    tscError("0x%"PRIx64" query cancelled or failed, sub:0x%"PRIx64", vgId:%d, orderOfSub:%d, code:%s, global code:%s",
+        pParentSql->self, pSql->self, pVgroup->vgId, trsupport->subqueryIndex, tstrerror(code), tstrerror(pParentSql->res.code));
+    if (subAndCheckDone(pSql, pParentSql, trsupport->subqueryIndex)) {
+      // all sub done, call parentSQL callback to finish
+      (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
+    }
+    tfree(pSql->param);
+    return;
+  }
+  
+  /*
+   * if a subquery on a vnode failed, all retrieve operations from vnode that occurs later
+   * than this one are actually not necessary, we simply call the tscRetrieveFromDnodeCallBack
+   * function to abort current and remain retrieve process.
+   *
+   * NOTE: thread safe is required.
+   */
+  if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
+    tscError(":CDEL 0x%"PRIx64" sub:0x%"PRIx64" reach the max retry times or no need to retry, set global code:%s", pParentSql->self, pSql->self, tstrerror(code));
+    atomic_val_compare_exchange_32(&pParentSql->res.code, TSDB_CODE_SUCCESS, code);  // set global code and abort
+    tscHandleSubDeleteError(param, tres, pParentSql->res.code);
+    if (subAndCheckDone(pSql, pParentSql, trsupport->subqueryIndex)) {
+      // all sub done, call parentSQL callback to finish
+      (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
+    }
+    tfree(pSql->param);
+    return;
+  }
+
+  // record
+  tscInfo("0x%"PRIx64":CDEL sub:0x%"PRIx64" query complete, ep:%s, vgId:%d, orderOfSub:%d, retrieve row(s)=%d tables(s)=%d", trsupport->pParentSql->self,
+      pSql->self, pVgroup->epAddr[pSql->epSet.inUse].fqdn, pVgroup->vgId, trsupport->subqueryIndex, pSql->res.numOfRows, pSql->res.numOfTables);
+
+  // success do total count
+  SSubqueryState *subState = &pParentSql->subState;
+  pthread_mutex_lock(&subState->mutex);
+  pParentSql->res.numOfRows   += pSql->res.numOfRows;
+  pParentSql->res.numOfTables += pSql->res.numOfTables;
+  pthread_mutex_unlock(&subState->mutex);
+
+  if (subAndCheckDone(pSql, pParentSql, trsupport->subqueryIndex)) {
+    // all sub done, call parentSQL callback to finish
+    (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
+  }
+  tfree(pSql->param);
+
+  return ;
+}
+
+void writeMsgVgId(char * payload, int32_t vgId) {
+  SSubmitMsg* pSubmitMsg = (SSubmitMsg *)(payload + sizeof(SMsgDesc)); 
+  // SSubmitMsg
+  pSubmitMsg->header.vgId = htonl(vgId);
+}
+
+//
+// STable malloc sub delete
+//
+SSqlObj *tscCreateSTableSubDelete(SSqlObj *pSql, SVgroupMsg* pVgroupMsg, SRetrieveSupport *trsupport) {
+  // Init
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
+  if (pNew == NULL) {
+    tscError("0x%"PRIx64":CDEL new subdelete failed.", pSql->self);
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pNew->pTscObj   = pSql->pTscObj;
+  pNew->signature = pNew;
+  pNew->sqlstr    = strdup(pSql->sqlstr);
+  pNew->rootObj   = pSql->rootObj;
+  pNew->fp        = tscSubDeleteCallback;
+  pNew->fetchFp   = tscSubDeleteCallback;
+  pNew->param     = trsupport;
+  pNew->maxRetry  = TSDB_MAX_REPLICA;
+
+  SSqlCmd* pNewCmd  = &pNew->cmd;
+  memcpy(pNewCmd, pCmd, sizeof(SSqlCmd));
+  // set zero
+  pNewCmd->pQueryInfo = NULL;
+  pNewCmd->active = NULL;
+  pNewCmd->payload = NULL;
+  pNewCmd->allocSize = 0;
+  
+  // payload copy
+  int32_t ret = tscAllocPayload(pNewCmd, pCmd->payloadLen);
+  if (ret != TSDB_CODE_SUCCESS) {
+    tscError("0x%"PRIx64":CDEL , sub delete alloc payload failed. errcode=%d", pSql->self, ret);
+    free(pNew);
+    return NULL;
+  }
+  memcpy(pNewCmd->payload, pCmd->payload, pCmd->payloadLen);
+  
+  // update vgroup id
+  writeMsgVgId(pNewCmd->payload ,pVgroupMsg->vgId);
+
+  tsem_init(&pNew->rspSem, 0, 0);
+  registerSqlObj(pNew);
+  tscDebug("0x%"PRIx64":CDEL new sub insertion: %p", pSql->self, pNew);
+
+  SNewVgroupInfo vgroupInfo = {0};
+  taosHashGetClone(UTIL_GET_VGROUPMAP(pSql), &pVgroupMsg->vgId, sizeof(pVgroupMsg->vgId), NULL, &vgroupInfo);
+  tscDumpEpSetFromVgroupInfo(&pNew->epSet, &vgroupInfo);
+
+  return pNew;
+}
+
+//
+// execute delete sql
+//
+int32_t executeDelete(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
+
+  int32_t ret = TSDB_CODE_SUCCESS;
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  if(!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+    // not super table
+    pSql->cmd.active = pQueryInfo;
+    return tscBuildAndSendRequest(pSql, pQueryInfo);
+  }
+
+  //
+  // super table
+  //
+
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+  
+  // check cancel
+  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+    pCmd->command = TSDB_SQL_RETRIEVE_GLOBALMERGE;  // enable the abort of kill super table function.
+    return pRes->code;
+  }
+
+  if(pTableMetaInfo->vgroupList == NULL) {
+    tscError(":CDEL SQL:%p tablename=%s vgroupList is NULL.", pSql, pTableMetaInfo->name.tname);
+    return TSDB_CODE_VND_INVALID_VGROUP_ID;
+  }
+  
+  SSubqueryState *pState = &pSql->subState;
+  int32_t numOfSub = pTableMetaInfo->vgroupList->numOfVgroups;
+
+  ret = doInitSubState(pSql, numOfSub);
+  if (ret != 0) {
+    tscAsyncResultOnError(pSql);
+    return ret;
+  }
+
+  tscDebug("0x%"PRIx64":CDEL retrieved query data from %d vnode(s)", pSql->self, pState->numOfSub);
+  pRes->code = TSDB_CODE_SUCCESS;
+  
+  int32_t i;
+  for (i = 0; i < pState->numOfSub; ++i) {
+    // vgroup
+    SVgroupMsg* pVgroupMsg = &pTableMetaInfo->vgroupList->vgroups[i];
+
+    // malloc each support
+    SRetrieveSupport *trs = (SRetrieveSupport *)calloc(1, sizeof(SRetrieveSupport));
+    if (trs == NULL) {
+      tscError("0x%"PRIx64" failed to malloc buffer for SRetrieveSupport, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
+      break;
+    }
+    trs->subqueryIndex = i;
+    trs->pParentSql    = pSql;
+
+    // malloc sub SSqlObj
+    SSqlObj *pNew = tscCreateSTableSubDelete(pSql, pVgroupMsg, trs);
+    if (pNew == NULL) {
+      tscError("0x%"PRIx64"CDEL failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
+      tfree(trs);
+      break;
+    }
+    pSql->pSubs[i] = pNew;
+  }
+  
+  if (i < pState->numOfSub) {
+    tscError("0x%"PRIx64":CDEL failed to prepare subdelete structure and launch subqueries", pSql->self);
+    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    
+    doCleanupSubqueries(pSql, i);
+    return pRes->code;   // free all allocated resource
+  }
+  
+  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+    doCleanupSubqueries(pSql, i);
+    return pRes->code;
+  }
+
+  // send sub sql
+  doConcurrentlySendSubQueries(pSql);
+  //return TSDB_CODE_TSC_QUERY_CANCELLED;
+
+  return TSDB_CODE_SUCCESS;
+}
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index af8c6837219cc32e22491427f04a19f70a8e50b0..979408b19d8e36315c9c37a73d2ae3f8c559f721 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1153,7 +1153,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
 
     code = validateTableName(tableToken.z, tableToken.n, &sTblToken, &dbIncluded2);
     if (code != TSDB_CODE_SUCCESS) {
-      return tscInvalidOperationMsg(pInsertParam->msg, "invalid table name", *sqlstr);
+      return tscInvalidOperationMsg(pInsertParam->msg, STR_INVALID_TABLE_NAME, *sqlstr);
     }
 
     int32_t ret = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded2);
@@ -1441,7 +1441,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
     bool dbIncluded = false;
     // Check if the table name available or not
     if (validateTableName(sToken.z, sToken.n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
-      code = tscInvalidOperationMsg(pInsertParam->msg, "table name invalid", sToken.z);
+      code = tscInvalidOperationMsg(pInsertParam->msg, STR_INVALID_TABLE_NAME, sToken.z);
       goto _clean;
     }
 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index b20b271c82ef264e663a70c59e30c1f19c9328f1..43b849451972cd53740d3531fd4097909231acf4 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -100,7 +100,7 @@ static int32_t validateStateWindowNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
 
 static int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExprItem* pItem, bool outerQuery, bool timeWindowQuery);
 
-static int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql, bool joinQuery);
+static int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql, bool joinQuery, bool delData);
 static int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode);
 static int32_t validateRangeNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode);
 static int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, SSchema* pSchema);
@@ -761,8 +761,6 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
 
     case TSDB_SQL_DESCRIBE_TABLE: {
-      const char* msg1 = "invalid table name";
-
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       bool dbIncluded = false;
       char      buf[TSDB_TABLE_FNAME_LEN];
@@ -770,7 +768,7 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       sTblToken.z = buf;
 
       if (validateTableName(pToken->z, pToken->n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
-        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
       }
 
       // additional msg has been attached already
@@ -783,8 +781,6 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
     case TSDB_SQL_SHOW_CREATE_STABLE:
     case TSDB_SQL_SHOW_CREATE_TABLE: {
-      const char* msg1 = "invalid table name";
-
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
 
       bool dbIncluded = false;
@@ -793,7 +789,7 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       sTblToken.z = buf;
 
       if (validateTableName(pToken->z, pToken->n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
-        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
       }
 
       code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded);
@@ -1052,6 +1048,47 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       }
       break;
     }
+    case TSDB_SQL_DELETE_DATA: {
+      // CHECK AND SET TABLE NAME
+      SStrToken* tbName = &pInfo->pDelData->tableName;
+      bool dbIncluded = false;
+      char      buf[TSDB_TABLE_FNAME_LEN];
+      SStrToken sTblToken;
+      sTblToken.z = buf;
+      // check
+      if (validateTableName(tbName->z, tbName->n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
+      }
+      // set
+      code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+
+      // get table meta
+      code = tscGetTableMeta(pSql, pTableMetaInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code ; // async load table meta
+      }
+      
+      // vgroupInfo if super
+      if (code == 0 && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+        code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
+      }
+      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+        return code;
+      }
+
+      // CHECK AND SET WHERE
+      if (pInfo->pDelData->pWhere) {
+        // origin check
+        pQueryInfo = tscGetQueryInfo(pCmd);
+        if (validateWhereNode(pQueryInfo, &pInfo->pDelData->pWhere, pSql, false, true) != TSDB_CODE_SUCCESS) {
+          return TSDB_CODE_TSC_INVALID_OPERATION;
+        }
+      }
+      break;
+    }
     default:
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
   }
@@ -5599,12 +5636,13 @@ void convertWhereStringCharset(tSqlExpr* pRight){
 
 static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr,
                                      int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr,
-                                     tSqlExpr** tsExpr, bool joinQuery) {
+                                     tSqlExpr** tsExpr, bool joinQuery, bool delData) {
   const char* msg1 = "table query cannot use tags filter";
   const char* msg2 = "illegal column name";
   const char* msg4 = "too many join tables";
   const char* msg5 = "not support ordinary column join";
   const char* msg6 = "illegal condition expression";
+  const char* msg7 = "only allow first timestamp column and tag column";
 
   tSqlExpr* pLeft  = (*pExpr)->pLeft;
   tSqlExpr* pRight = (*pExpr)->pRight;
@@ -5629,6 +5667,16 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
+  SSchema*        pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
+
+  // delete where condition check , column must ts or tag
+  if (delData) {
+    if (!((pSchema->colId == PRIMARYKEY_TIMESTAMP_COL_INDEX && pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) ||
+           index.columnIndex >= tscGetNumOfColumns(pTableMeta) ||
+           index.columnIndex == TSDB_TBNAME_COLUMN_INDEX)) {
+             return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
+    }
+  }
 
   // validate the null expression
   int32_t code = validateNullExpr(*pExpr, pTableMeta, index.columnIndex, tscGetErrorMsgPayload(pCmd));
@@ -5648,8 +5696,6 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
     return code;
   }
 
-  SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
-
   if (pSchema->type == TSDB_DATA_TYPE_NCHAR){
     convertWhereStringCharset(pRight);
   }
@@ -5798,7 +5844,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
 
 int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr,
                         int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr,
-                        tSqlExpr** tsExpr, bool joinQuery) {
+                        tSqlExpr** tsExpr, bool joinQuery, bool delData) {
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -5830,12 +5876,12 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
   int32_t rightTbIdx = 0;
 
   if (!tSqlExprIsParentOfLeaf(*pExpr)) {
-    ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, pCondExpr, type ? &leftType : NULL, &leftTbIdx, (*pExpr)->tokenId, &columnLeft, &tsLeft, joinQuery);
+    ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, pCondExpr, type ? &leftType : NULL, &leftTbIdx, (*pExpr)->tokenId, &columnLeft, &tsLeft, joinQuery, delData);
     if (ret != TSDB_CODE_SUCCESS) {
       goto err_ret;
     }
 
-    ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, pCondExpr, type ? &rightType : NULL, &rightTbIdx, (*pExpr)->tokenId, &columnRight, &tsRight, joinQuery);
+    ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, pCondExpr, type ? &rightType : NULL, &rightTbIdx, (*pExpr)->tokenId, &columnRight, &tsRight, joinQuery, delData);
     if (ret != TSDB_CODE_SUCCESS) {
       goto err_ret;
     }
@@ -5890,7 +5936,7 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
     goto err_ret;
   }
 
-  ret = handleExprInQueryCond(pCmd, pQueryInfo, pExpr, pCondExpr, type, tbIdx, parentOptr, columnExpr, tsExpr, joinQuery);
+  ret = handleExprInQueryCond(pCmd, pQueryInfo, pExpr, pCondExpr, type, tbIdx, parentOptr, columnExpr, tsExpr, joinQuery, delData);
   if (ret) {
     goto err_ret;
   }
@@ -6437,13 +6483,13 @@ _ret:
 
 
 
-int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql, bool joinQuery) {
+int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql, bool joinQuery, bool delData) {
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
   }
 
   const char* msg1 = "invalid expression";
-//  const char* msg2 = "invalid filter expression";
+  //const char* msg2 = "the timestamp column condition must be in an interval";
 
   int32_t ret = TSDB_CODE_SUCCESS;
 
@@ -6465,7 +6511,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   }
 #endif
 
-  if ((ret = getQueryCondExpr(&pSql->cmd, pQueryInfo, pExpr, &condExpr, etype, &tbIdx, (*pExpr)->tokenId, &condExpr.pColumnCond, &condExpr.pTimewindow, joinQuery)) != TSDB_CODE_SUCCESS) {
+  if ((ret = getQueryCondExpr(&pSql->cmd, pQueryInfo, pExpr, &condExpr, etype, &tbIdx, (*pExpr)->tokenId, &condExpr.pColumnCond, &condExpr.pTimewindow, joinQuery, delData)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
   }
 
@@ -6494,6 +6540,11 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
     goto PARSE_WHERE_EXIT;
   }
 
+  // check timestamp range
+  //if (pQueryInfo->window.skey > pQueryInfo->window.ekey) {
+  //  return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
+  //}
+
   // get the tag query condition
   if ((ret = getTagQueryCondExpr(&pSql->cmd, pQueryInfo, &condExpr)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
@@ -8998,7 +9049,6 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
 }
 
 int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
-  const char* msg1 = "invalid table name";
   const char* msg3 = "tag value too long";
   const char* msg4 = "illegal value or data overflow";
   const char* msg5 = "tags number not matched";
@@ -9034,7 +9084,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 
     int32_t code = validateTableName(pToken->z, pToken->n, &sTblToken, &dbIncluded);
     if (code != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
 
     code = tscSetTableFullName(&pStableMetaInfo->name, &sTblToken, pSql, dbIncluded);
@@ -9241,7 +9291,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     bool dbIncluded2 = false;
     // table name
     if (tscValidateName(&(pCreateTableInfo->name), true, &dbIncluded2) != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
@@ -9253,7 +9303,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     pCreateTableInfo->fullname = calloc(1, tNameLen(&pTableMetaInfo->name) + 1);
     ret = tNameExtractFullName(&pTableMetaInfo->name, pCreateTableInfo->fullname);
     if (ret != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
   }
 
@@ -9261,7 +9311,6 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 }
 
 int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
-  const char* msg1 = "invalid table name";
   const char* msg2 = "functions not allowed in CQ";
   const char* msg3 = "fill only available for interval query";
   const char* msg4 = "fill option not supported in stream computing";
@@ -9285,14 +9334,14 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   bool dbIncluded1 = false;
 
   if (tscValidateName(pName, true, &dbIncluded1) != TSDB_CODE_SUCCESS) {
-    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
   }
   
   // check to valid and create to name
   if(pInfo->pCreateTableInfo->to.n > 0) {
     bool dbInclude = false;
     if (tscValidateName(&pInfo->pCreateTableInfo->to, false, &dbInclude) != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
     int32_t code = tscSetTableFullName(&pInfo->pCreateTableInfo->toSName, &pInfo->pCreateTableInfo->to, pSql, dbInclude);
     if(code != TSDB_CODE_SUCCESS) {
@@ -9319,7 +9368,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
 
   int32_t code = validateTableName(srcToken.z, srcToken.n, &sTblToken, &dbIncluded2);
   if (code != TSDB_CODE_SUCCESS) {
-    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
   }
 
   code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded2);
@@ -9339,7 +9388,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   int32_t joinQuery = (pSqlNode->from != NULL && taosArrayGetSize(pSqlNode->from->list) > 1);
 
   if (pSqlNode->pWhere != NULL) {  // query condition in stream computing
-    if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery) != TSDB_CODE_SUCCESS) {
+    if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery, false) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
@@ -9751,7 +9800,6 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
 }
 
 static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, char* msgBuf, SSqlObj* pSql) {
-  const char* msg1 = "invalid table name";
 
   int32_t numOfTables = (int32_t) taosArrayGetSize(pSqlNode->from->list);
   assert(pSqlNode->from->type == SQL_NODE_FROM_TABLELIST);
@@ -9761,7 +9809,7 @@ static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList
 
     SStrToken* t = &item->tableName;
     if (t->type == TK_INTEGER || t->type == TK_FLOAT) {
-      return invalidOperationMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, STR_INVALID_TABLE_NAME);
     }
     
     bool dbIncluded = false;
@@ -9770,7 +9818,7 @@ static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList
     sTblToken.z = buf;
     
     if (validateTableName(t->z, t->n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, STR_INVALID_TABLE_NAME);
     }
 
     SName name = {0};
@@ -10029,7 +10077,6 @@ _end:
 }
 
 static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, int32_t numOfTables) {
-  const char* msg1 = "invalid table name";
   const char* msg2 = "invalid table alias name";
   const char* msg3 = "alias name too long";
   const char* msg4 = "self join not allowed";
@@ -10050,7 +10097,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     SStrToken       *oriName = &item->tableName;
 
     if (oriName->type == TK_INTEGER || oriName->type == TK_FLOAT) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
 
     bool dbIncluded = false;
@@ -10059,7 +10106,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     sTblToken.z = buf;
 
     if (validateTableName(oriName->z, oriName->n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), STR_INVALID_TABLE_NAME);
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
@@ -10328,7 +10375,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     // validate the query filter condition info
     if (pSqlNode->pWhere != NULL) {
-      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery) != TSDB_CODE_SUCCESS) {
+      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery, false) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     } else {
@@ -10433,7 +10480,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     pQueryInfo->onlyHasTagCond = true;
     // set where info
     if (pSqlNode->pWhere != NULL) {
-      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery) != TSDB_CODE_SUCCESS) {
+      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql, joinQuery, false) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index c821c25987042d0c26c4aa302a142544a08b943c..67c7d2b1e8d112f98a66fb72b61d82c41ee11fe5 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -130,7 +130,7 @@ void tscUpdateMgmtEpSet(SSqlObj *pSql, SRpcEpSet *pEpSet) {
   taosCorEndWrite(&pCorEpSet->version);
 }
 
-static void tscDumpEpSetFromVgroupInfo(SRpcEpSet *pEpSet, SNewVgroupInfo *pVgroupInfo) {
+void tscDumpEpSetFromVgroupInfo(SRpcEpSet *pEpSet, SNewVgroupInfo *pVgroupInfo) {
   if (pVgroupInfo == NULL) { return;}
   int8_t inUse = pVgroupInfo->inUse;
   pEpSet->inUse = (inUse >= 0 && inUse < TSDB_MAX_REPLICA) ? inUse: 0; 
@@ -523,9 +523,12 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
       pMsg->numOfRows = htonl(pMsg->numOfRows);
       pMsg->affectedRows = htonl(pMsg->affectedRows);
       pMsg->failedRows = htonl(pMsg->failedRows);
-      pMsg->numOfFailedBlocks = htonl(pMsg->numOfFailedBlocks);
+      pMsg->numOfTables = htonl(pMsg->numOfTables);
 
       pRes->numOfRows += pMsg->affectedRows;
+      if(pMsg->numOfTables > 0) {
+        pRes->numOfTables = pMsg->numOfTables;
+      }
       tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s inserted rows:%d rspLen:%d", pSql->self, sqlCmd[pCmd->command],
                tstrerror(pRes->code), pMsg->affectedRows, pRes->rspLen);
     } else {
@@ -619,7 +622,7 @@ int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
   }
 
   tscDebug("0x%"PRIx64" SQL cmd:%s will be processed, name:%s, type:%d", pSql->self, sqlCmd[pCmd->command], name, type);
-  if (pCmd->command < TSDB_SQL_MGMT) { // the pTableMetaInfo cannot be NULL
+  if (pCmd->command < TSDB_SQL_MGMT && pCmd->command != TSDB_SQL_DELETE_DATA) { // the pTableMetaInfo cannot be NULL
     if (pTableMetaInfo == NULL) {
       pSql->res.code = TSDB_CODE_TSC_APP_ERROR;
       return pSql->res.code;
@@ -3313,10 +3316,91 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
   return code;
 }
 
+int tscBuildDelDataMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd        *pCmd           = &pSql->cmd;
+  SQueryInfo     *pQueryInfo     = tscGetQueryInfo(pCmd);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STableMeta     *pTableMeta     = pTableMetaInfo->pTableMeta;
+  uint32_t       command         = CMD_DELETE_DATA;
+  
+  // pSql->cmd.payloadLen is set during copying data into payload
+  pCmd->msgType = TSDB_MSG_TYPE_SUBMIT;
+  if (pTableMeta->tableType == TSDB_SUPER_TABLE) {
+    // super table to do
+    command |= FLAG_SUPER_TABLE;
+  } else {
+    // no super table to do  copy epSet
+    SNewVgroupInfo vgroupInfo = {0};
+    taosHashGetClone(UTIL_GET_VGROUPMAP(pSql), &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo);
+    tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
+    tscDebug("0x%"PRIx64" table deldata submit msg built, numberOfEP:%d", pSql->self, pSql->epSet.numOfEps);
+  }
+
+  SCond *pCond = NULL;
+  // serialize tag column query condition
+  if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0) {
+    STagCond* pTagCond = &pQueryInfo->tagCond;
+    pCond = tsGetSTableQueryCond(pTagCond, pTableMeta->id.uid);
+  }
+
+  // set payload
+  int32_t tagCondLen = 0;
+  if (pCond) {
+    tagCondLen = pCond->len;
+  }
+
+  int32_t payloadLen = sizeof(SMsgDesc) + sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + sizeof(SControlData) + tagCondLen;
+    
+  int32_t ret = tscAllocPayload(pCmd, payloadLen);
+  if (ret != TSDB_CODE_SUCCESS) {
+    return ret;
+  }
+  pCmd->payloadLen = payloadLen;
+
+  char* p = pCmd->payload;
+  SMsgDesc* pMsgDesc = (SMsgDesc* )p;
+  p += sizeof(SMsgDesc);
+  SSubmitMsg* pSubmitMsg = (SSubmitMsg* )p;
+  p += sizeof(SSubmitMsg);
+  SSubmitBlk* pSubmitBlk = (SSubmitBlk*)p;
+  p += sizeof(SSubmitBlk);
+  SControlData* pControlData = (SControlData* )p;
+
+  // SMsgDesc
+  pMsgDesc->numOfVnodes = htonl(1);
+  // SSubmitMsg
+  int32_t size = pCmd->payloadLen - sizeof(SMsgDesc);
+  pSubmitMsg->header.vgId    = htonl(pTableMeta->vgId);
+  pSubmitMsg->header.contLen = htonl(size);
+  pSubmitMsg->length         = pSubmitMsg->header.contLen;
+  pSubmitMsg->numOfBlocks    = htonl(1);
+  // SSubmitBlk
+  pSubmitBlk->flag      = FLAG_BLK_CONTROL; // this is control block
+  pSubmitBlk->tid       = htonl(pTableMeta->id.tid);
+  pSubmitBlk->uid       = htobe64(pTableMeta->id.uid);
+  pSubmitBlk->numOfRows = htons(1);
+  pSubmitBlk->schemaLen = 0; // only server return TSDB_CODE_TDB_TABLE_RECONFIGURE need schema attached
+  pSubmitBlk->sversion  = htonl(pTableMeta->sversion);
+  pSubmitBlk->dataLen   = htonl(sizeof(SControlData) + tagCondLen);
+  // SControlData
+  pControlData->command  = htonl(command);
+  pControlData->win.skey = htobe64(pQueryInfo->window.skey);
+  pControlData->win.ekey = htobe64(pQueryInfo->window.ekey);
+
+  // set tagCond
+  if (pCond) {
+    pControlData->tagCondLen = htonl(pCond->len);
+    memcpy(pControlData->tagCond, pCond->cond, pCond->len);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
   tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg;
   tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg;
+  tscBuildMsg[TSDB_SQL_DELETE_DATA] = tscBuildDelDataMsg;
 
   tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
   tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
@@ -3392,5 +3476,4 @@ void tscInitMsgsFp() {
   tscKeepConn[TSDB_SQL_SELECT] = 1;
   tscKeepConn[TSDB_SQL_FETCH] = 1;
   tscKeepConn[TSDB_SQL_HB] = 1;
-}
-
+}
\ No newline at end of file
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 879fed06669162dbf10f48c00415c7246b5548a6..849fe0ba73c20c16db40a593a38648566ca1265d 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -435,6 +435,13 @@ int taos_affected_rows(TAOS_RES *tres) {
   return pSql->res.numOfRows;
 }
 
+int taos_affected_tables(TAOS_RES *tres) {
+  SSqlObj* pSql = (SSqlObj*) tres;
+  if (pSql == NULL || pSql->signature != pSql) return 0;
+
+  return pSql->res.numOfTables;
+}
+
 TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
   SSqlObj *pSql = (SSqlObj *)res;
   SSqlRes *pRes = &pSql->res;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 4482f846d902e673eb5d7d15c8ffe2db899c725f..449d816e76e606f070af310ef7840027a388d396 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -2034,8 +2034,6 @@ _return:
 /////////////////////////////////////////////////////////////////////////////////////////
 static void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code);
 
-static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj);
-
 int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter *pSupporter) {
   SSqlCmd *   pCmd = &pSql->cmd;
   SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
@@ -2707,7 +2705,7 @@ static void doSendQueryReqs(SSchedMsg* pSchedMsg) {
   tfree(p);
 }
 
-static void doConcurrentlySendSubQueries(SSqlObj* pSql) {
+void doConcurrentlySendSubQueries(SSqlObj* pSql) {
   SSubqueryState *pState = &pSql->subState;
 
   // concurrently sent the query requests.
@@ -2810,7 +2808,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     trs->subqueryIndex = i;
     trs->pParentSql    = pSql;
 
-    SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
+    SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL, tscRetrieveDataRes, TSDB_SQL_SELECT);
     if (pNew == NULL) {
       tscError("0x%"PRIx64" failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
       tfree(trs->localBuffer);
@@ -2913,7 +2911,7 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
   tscError("0x%"PRIx64" sub:0x%"PRIx64" retrieve/query failed, code:%s, orderOfSub:%d, retry:%d", trsupport->pParentSql->self, pSql->self,
            tstrerror(code), subqueryIndex, trsupport->numOfRetry);
 
-  SSqlObj *pNew = tscCreateSTableSubquery(trsupport->pParentSql, trsupport, pSql);
+  SSqlObj *pNew = tscCreateSTableSubquery(trsupport->pParentSql, trsupport, pSql,tscRetrieveDataRes, TSDB_SQL_SELECT);
   if (pNew == NULL) {
     tscError("0x%"PRIx64" sub:0x%"PRIx64" failed to create new subquery due to error:%s, abort retry, vgId:%d, orderOfSub:%d",
              oriTrs->pParentSql->self, pSql->self, tstrerror(terrno), pVgroup->vgId, oriTrs->subqueryIndex);
@@ -3259,12 +3257,12 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
   }
 }
 
-static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj) {
+SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj, __async_cb_func_t fp, int32_t cmd) {
   const int32_t table_index = 0;
   SSqlCmd *   pCmd = &pSql->cmd;
   SQueryInfo *pPQueryInfo = tscGetQueryInfo(pCmd); // Parent SQueryInfo
   
-  SSqlObj *pNew = createSubqueryObj(pSql, table_index, tscRetrieveDataRes, trsupport, TSDB_SQL_SELECT, prevSqlObj);
+  SSqlObj *pNew = createSubqueryObj(pSql, table_index, fp, trsupport, cmd, prevSqlObj);
   if (pNew != NULL) {  // the sub query of two-stage super table query
     SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd);
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index c23ba15d44928bb4023c5615edb792f81b1de3d5..c385e37fb96d7e23ac7d1527e5a8e60654925a64 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -30,6 +30,7 @@
 #include "ttimer.h"
 #include "ttokendef.h"
 #include "cJSON.h"
+#include "tscDelete.h"
 
 #ifdef HTTP_EMBEDDED
 #include "httpInt.h"
@@ -3339,6 +3340,9 @@ bool tscShouldBeFreed(SSqlObj* pSql) {
 STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd* pCmd, int32_t tableIndex) {
   assert(pCmd != NULL);
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  if(pQueryInfo == NULL) {
+    return NULL;
+  }
   return tscGetMetaInfo(pQueryInfo, tableIndex);
 }
 
@@ -4209,7 +4213,13 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
     (*pSql->fp)(pSql->param, pSql, 0);
     return;
-  }
+  } else if (pSql->cmd.command == TSDB_SQL_DELETE_DATA) {
+    code = executeDelete(pSql, pQueryInfo);
+    if (code != TSDB_CODE_SUCCESS) {
+      (*pSql->fp)(pSql->param, pSql, 0);
+    }
+    return ;
+  } 
 
   if (pSql->cmd.command == TSDB_SQL_SELECT) {
     tscAddIntoSqlList(pSql);
@@ -4349,6 +4359,15 @@ bool tscIsUpdateQuery(SSqlObj* pSql) {
   return ((pCmd->command >= TSDB_SQL_INSERT && pCmd->command <= TSDB_SQL_DROP_DNODE) || TSDB_SQL_RESET_CACHE == pCmd->command || TSDB_SQL_USE_DB == pCmd->command);
 }
 
+bool tscIsDeleteQuery(SSqlObj* pSql) {
+  if (pSql == NULL || pSql->signature != pSql) {
+    return false;
+  }
+
+  SSqlCmd* pCmd = &pSql->cmd;
+  return pCmd->command == TSDB_SQL_DELETE_DATA;
+}
+
 char* tscGetSqlStr(SSqlObj* pSql) {
   if (pSql == NULL || pSql->signature != pSql) {
     return NULL;
diff --git a/src/common/inc/tcmdtype.h b/src/common/inc/tcmdtype.h
index 918763ebb4b92399872f10c0dd632689eaa08d1b..e27d273667491463e5159c35d60ce075b167806e 100644
--- a/src/common/inc/tcmdtype.h
+++ b/src/common/inc/tcmdtype.h
@@ -35,6 +35,7 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SELECT, "select" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_FETCH, "fetch" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_INSERT, "insert" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DELETE_DATA, "delete-data" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_UPDATE_TAGS_VAL, "update-tag-val" )
 
   // the SQL below is for mgmt node
diff --git a/src/common/inc/tname.h b/src/common/inc/tname.h
index 6c4b54ec3cfb2f46acf5341ecda7015035866e59..ba9705b9be54b3102a4957db310dcc4579a7dcde 100644
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -141,4 +141,7 @@ int32_t tNameSetAcctId(SName* dst, const char* acct);
 
 int32_t tNameSetDbName(SName* dst, const char* acct, SStrToken* dbToken);
 
+// define uniform string
+#define STR_INVALID_TABLE_NAME "invalid table name"
+
 #endif  // TDENGINE_NAME_H
diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c
index e0576e2d8b5b23f9932b8893f2cd2d1db2d21115..356d246b54efc876467512ff78d8686e2646d662 100644
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -514,7 +514,7 @@ static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row) {
   pBlk->tid = htonl(pObj->tid);
   pBlk->numOfRows = htons(1);
   pBlk->sversion = htonl(pSchema->version);
-  pBlk->padding = 0;
+  pBlk->flag = 0;
 
   pHead->len = sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + memRowDataTLen(trow);
 
diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c
index ed2a6e210939e907e89dd07de27481d385e4ef24..a9d648793d098bfb7cad05a4ca8d034fe86c1399 100644
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@@ -17,6 +17,7 @@
 #include "os.h"
 #include "tqueue.h"
 #include "dnodeVWrite.h"
+#include "tthread.h"
 
 typedef struct {
   taos_qall qall;
@@ -161,6 +162,40 @@ void dnodeFreeVWriteQueue(void *pWqueue) {
   taosCloseQueue(pWqueue);
 }
 
+void* waitingResultThread(void* param) {
+  SVWriteMsg* pWrite = (SVWriteMsg* )param;
+
+  // wait AddWaitThread to list finished
+  dDebug(":SDEL pVnode:%p wait AddWaitThread finished... pWrite=%p", pWrite->pVnode, pWrite);
+  tsem_t* psem = vnodeSemWait(pWrite->pVnode);
+  tsem_wait(psem);
+  tsem_post(psem);
+  dDebug(":SDEL pVnode:%p wait AddWaitThread ok pWrite=%p", pWrite->pVnode, pWrite);
+
+  // wait request deal finished
+  int32_t ret = tsem_wait(pWrite->rspRet.psem);
+  dDebug(":SDEL pVnode:%p wait request ok pWrite=%p", pWrite->pVnode, pWrite);
+  if(ret == 0) {
+    // success
+  }
+  tsem_destroy(pWrite->rspRet.psem);
+  tfree(pWrite->rspRet.psem);
+
+  // wait ok
+  SRpcMsg rpcRsp = {
+    .handle  = pWrite->rpcMsg.handle,
+    .pCont   = pWrite->rspRet.rsp,
+    .contLen = pWrite->rspRet.len,
+    .code    = pWrite->code,
+  };
+
+  rpcSendResponse(&rpcRsp);
+  // remove from thread manager
+  vnodeRemoveWait(pWrite->pVnode, pWrite);
+  vnodeFreeFromWQueue(pWrite->pVnode, pWrite);
+  return NULL;
+}
+
 void dnodeSendRpcVWriteRsp(void *pVnode, void *wparam, int32_t code) {
   if (wparam == NULL) return;
   SVWriteMsg *pWrite = wparam;
@@ -177,8 +212,27 @@ void dnodeSendRpcVWriteRsp(void *pVnode, void *wparam, int32_t code) {
     .code    = pWrite->code,
   };
 
-  rpcSendResponse(&rpcRsp);
-  vnodeFreeFromWQueue(pVnode, pWrite);
+  if(pWrite->rspRet.psem == 0)  {
+    // no wait response
+    rpcSendResponse(&rpcRsp);
+    vnodeFreeFromWQueue(pVnode, pWrite);
+  } else {
+    if (vnodeWaitTooMany(pVnode)) {
+      // too many wait , so can not wait again
+      rpcRsp.code = TSDB_CODE_APP_NOT_READY;
+      rpcSendResponse(&rpcRsp);
+      vnodeFreeFromWQueue(pVnode, pWrite);
+    } else {
+      tsem_t* psem = vnodeSemWait(pVnode);
+      tsem_wait(psem);
+      // need async to wait result in another thread
+      pthread_t* thread = taosCreateThread(waitingResultThread, pWrite);
+      // add to wait thread manager
+      vnodeAddWait(pVnode, thread, pWrite->rspRet.psem, pWrite);
+      dDebug(":SDEL pVnode=%p vnode add wait %p ok, tsem_post.", pVnode, pWrite);
+      tsem_post(psem);
+    }
+  }  
 }
 
 static void *dnodeProcessVWriteQueue(void *wparam) {
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 481fc0f21d6819a623bcb6c947fcfa69086597bc..5cb0420fe2e8a19d07bc08ebc89fccfc2af968d6 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -212,6 +212,8 @@ DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS* taos, char* lines[], int numLi
 
 DLL_EXPORT int32_t taos_parse_time(char* timestr, int64_t* time, int32_t len, int32_t timePrec, int8_t dayligth);
 
+DLL_EXPORT int taos_affected_tables(TAOS_RES *res);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 54c34f5d8abde6575c0aa1e41df910ef7043c4b5..6266926d55f2e7057732aa9fc882791479b19098 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -249,6 +249,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_NO_WRITE_AUTH             TAOS_DEF_ERROR_CODE(0, 0x0512)  //"Database write operation denied"
 #define TSDB_CODE_VND_IS_SYNCING                TAOS_DEF_ERROR_CODE(0, 0x0513)  //"Database is syncing"
 #define TSDB_CODE_VND_INVALID_TSDB_STATE        TAOS_DEF_ERROR_CODE(0, 0x0514)  //"Invalid tsdb state"
+#define TSDB_CODE_WAIT_THREAD_TOO_MANY          TAOS_DEF_ERROR_CODE(0, 0x0515) //"Wait threads too many"
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)  //"Invalid table ID")
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 2ef646d734caa3a17fb6b61417e7658afb8b7db8..1a8907efabc483233f7e12ce2511bfec339a8d6f 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -120,6 +120,10 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_TP, "drop-tp" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_TP, "use-tp" )	 
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_TP, "alter-tp" )
 
+// delete
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DELDATA, "delete-data" )
+
+
 #ifndef TAOS_MESSAGE_C
   TSDB_MSG_TYPE_MAX  // 105
 #endif
@@ -195,6 +199,9 @@ enum _mgmt_table {
 #define TSDB_COL_IS_UD_COL(f)       ((f&(~(TSDB_COL_NULL))) == TSDB_COL_UDC)
 #define TSDB_COL_REQ_NULL(f)        (((f)&TSDB_COL_NULL) != 0)
 
+// SSubmitBlk->flag define
+#define FLAG_BLK_CONTROL            0x00000001 // SSubmitBlk is a control block to submit
+#define IS_CONTROL_BLOCK(x)         (x->flag & FLAG_BLK_CONTROL)
 
 extern char *taosMsg[];
 
@@ -219,7 +226,7 @@ typedef struct SMsgHead {
 typedef struct SSubmitBlk {
   uint64_t uid;        // table unique id
   int32_t  tid;        // table id
-  int32_t  padding;    // TODO just for padding here
+  int32_t  flag;       // extend special information, can see FLAG_BLK_??? define
   int32_t  sversion;   // data schema version
   int32_t  dataLen;    // data part length, not including the SSubmitBlk head
   int32_t  schemaLen;  // schema length, if length is 0, no schema exists
@@ -249,7 +256,7 @@ typedef struct {
   int32_t              numOfRows;     // number of records the client is trying to write
   int32_t              affectedRows;  // number of records actually written
   int32_t              failedRows;    // number of failed records (exclude duplicate records)
-  int32_t              numOfFailedBlocks;
+  int32_t              numOfTables;   // affected tables
   SShellSubmitRspBlock failedBlocks[];
 } SShellSubmitRspMsg;
 
@@ -260,6 +267,11 @@ typedef struct SSchema {
   int16_t bytes;
 } SSchema;
 
+typedef struct STimeWindow {
+  TSKEY skey;
+  TSKEY ekey;
+} STimeWindow;
+
 typedef struct {
   int32_t  contLen;
   int32_t  vgId;
@@ -408,6 +420,23 @@ typedef struct {
   int32_t vgId;
 } SDropVnodeMsg, SSyncVnodeMsg, SCompactVnodeMsg;
 
+typedef struct {
+  int32_t     contLen;
+  int32_t     vgId;
+  uint64_t    uid;
+  uint16_t    nSpan;
+  char        tableFname[TSDB_TABLE_FNAME_LEN];
+  STimeWindow span[];
+} STruncateTblMsg;
+typedef struct {
+  int32_t     contLen;
+  int32_t     vgId;
+  uint64_t    uid;
+  uint16_t    nSpan;
+  char        tableFname[TSDB_TABLE_FNAME_LEN];
+  STimeWindow span[];
+} SDeleteDataMsg;
+
 typedef struct SColIndex {
   int16_t  colId;      // column id
   int16_t  colIndex;   // column index in colList if it is a normal column or index in tagColList if a tag
@@ -460,11 +489,6 @@ typedef struct STableIdInfo {
   TSKEY    key;  // last accessed ts, for subscription
 } STableIdInfo;
 
-typedef struct STimeWindow {
-  TSKEY skey;
-  TSKEY ekey;
-} STimeWindow;
-
 typedef struct {
   int32_t     tsOffset;         // offset value in current msg body, NOTE: ts list is compressed
   int32_t     tsLen;            // total length of ts comp block
@@ -564,6 +588,7 @@ typedef struct {
   uint8_t  role;
   uint8_t  replica;
   uint8_t  compact;
+  uint8_t  truncate;
 } SVnodeLoad;
 
 typedef struct {
@@ -977,6 +1002,21 @@ typedef struct {
   char    value[];
 } STLV;
 
+// Ox00000001 ~ 0x00010000 command id  16 items
+#define CMD_DELETE_DATA 0x00000001
+
+// 0x00010000 ~ 0x10000000 command flag 16 items
+#define FLAG_SUPER_TABLE 0x00010000
+
+#define GET_CTLDATA_SIZE(p) (sizeof(SControlData) + p->tnum * sizeof(int32_t))
+typedef struct SControlData {
+  uint32_t    command;  // see define CMD_???
+  STimeWindow win;
+  // tag cond
+  int32_t     tagCondLen;
+  char        tagCond[];
+} SControlData;
+
 enum {
   TLV_TYPE_END_MARK = -1,
   //TLV_TYPE_DUMMY = 1,
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 4406a3ae5486b612cf9a3255b6d35f4e24823ad6..73820ebef2a5be2eba7c8e99251bc0d857f58569 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -96,6 +96,7 @@ int        tsdbCloseRepo(STsdbRepo *repo, int toCommit);
 int32_t    tsdbConfigRepo(STsdbRepo *repo, STsdbCfg *pCfg);
 int        tsdbGetState(STsdbRepo *repo);
 int8_t     tsdbGetCompactState(STsdbRepo *repo);
+int8_t     tsdbGetDeleteState(STsdbRepo *repo);
 // --------- TSDB TABLE DEFINITION
 typedef struct {
   uint64_t uid;  // the unique table ID
@@ -159,7 +160,7 @@ typedef struct {
  *
  * @return the number of points inserted, -1 for failure and the error number is set
  */
-int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp);
+int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp, tsem_t** ppSem);
 
 // -- FOR QUERY TIME SERIES DATA
 
@@ -420,6 +421,9 @@ int tsdbSyncRecv(void *pRepo, SOCKET socketFd);
 // For TSDB Compact
 int tsdbCompact(STsdbRepo *pRepo);
 
+// For TSDB delete data
+int tsdbDeleteData(STsdbRepo *pRepo, void *param);
+
 // For TSDB Health Monitor
 
 // no problem return true
@@ -442,6 +446,8 @@ char* parseTagDatatoJson(void *p);
 typedef bool (*readover_callback)(void* param, int8_t type, int32_t tid);
 void tsdbAddScanCallback(TsdbQueryHandleT* queryHandle, readover_callback callback, void* param);
 
+int32_t tsdbTableTid(void* pTable);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index ae75440ff916fa7c8dc235670de32b64a648ee01..1926999b2cc33bfb9b1ecd1f70a511caed74140c 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -177,48 +177,49 @@
 #define TK_CONNECTION                     159
 #define TK_STREAM                         160
 #define TK_COLON                          161
-#define TK_ABORT                          162
-#define TK_AFTER                          163
-#define TK_ATTACH                         164
-#define TK_BEFORE                         165
-#define TK_BEGIN                          166
-#define TK_CASCADE                        167
-#define TK_CLUSTER                        168
-#define TK_CONFLICT                       169
-#define TK_COPY                           170
-#define TK_DEFERRED                       171
-#define TK_DELIMITERS                     172
-#define TK_DETACH                         173
-#define TK_EACH                           174
-#define TK_END                            175
-#define TK_EXPLAIN                        176
-#define TK_FAIL                           177
-#define TK_FOR                            178
-#define TK_IGNORE                         179
-#define TK_IMMEDIATE                      180
-#define TK_INITIALLY                      181
-#define TK_INSTEAD                        182
-#define TK_KEY                            183
-#define TK_OF                             184
-#define TK_RAISE                          185
-#define TK_REPLACE                        186
-#define TK_RESTRICT                       187
-#define TK_ROW                            188
-#define TK_STATEMENT                      189
-#define TK_TRIGGER                        190
-#define TK_VIEW                           191
-#define TK_IPTOKEN                        192
-#define TK_SEMI                           193
-#define TK_NONE                           194
-#define TK_PREV                           195
-#define TK_LINEAR                         196
-#define TK_IMPORT                         197
-#define TK_TBNAME                         198
-#define TK_JOIN                           199
-#define TK_INSERT                         200
-#define TK_INTO                           201
-#define TK_VALUES                         202
-#define TK_FILE                           203
+#define TK_DELETE                         162
+#define TK_ABORT                          163
+#define TK_AFTER                          164
+#define TK_ATTACH                         165
+#define TK_BEFORE                         166
+#define TK_BEGIN                          167
+#define TK_CASCADE                        168
+#define TK_CLUSTER                        169
+#define TK_CONFLICT                       170
+#define TK_COPY                           171
+#define TK_DEFERRED                       172
+#define TK_DELIMITERS                     173
+#define TK_DETACH                         174
+#define TK_EACH                           175
+#define TK_END                            176
+#define TK_EXPLAIN                        177
+#define TK_FAIL                           178
+#define TK_FOR                            179
+#define TK_IGNORE                         180
+#define TK_IMMEDIATE                      181
+#define TK_INITIALLY                      182
+#define TK_INSTEAD                        183
+#define TK_KEY                            184
+#define TK_OF                             185
+#define TK_RAISE                          186
+#define TK_REPLACE                        187
+#define TK_RESTRICT                       188
+#define TK_ROW                            189
+#define TK_STATEMENT                      190
+#define TK_TRIGGER                        191
+#define TK_VIEW                           192
+#define TK_IPTOKEN                        193
+#define TK_SEMI                           194
+#define TK_NONE                           195
+#define TK_PREV                           196
+#define TK_LINEAR                         197
+#define TK_IMPORT                         198
+#define TK_TBNAME                         199
+#define TK_JOIN                           200
+#define TK_INSERT                         201
+#define TK_INTO                           202
+#define TK_VALUES                         203
+#define TK_FILE                           204
 
 
 #define TK_SPACE                          300
diff --git a/src/inc/vnode.h b/src/inc/vnode.h
index 29766e39842e9b53243e4d367116c8bc9ed35f7a..41f3eca08bdebc63c0c6eda96c95774334f09074 100644
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
@@ -32,6 +32,7 @@ typedef struct {
   int32_t len;
   void *  rsp;
   void *  qhandle;  // used by query and retrieve msg
+  tsem_t* psem;  // if it is not zero, need wait result with async 
 } SRspRet;
 
 typedef struct {
@@ -58,6 +59,13 @@ typedef struct {
   SWalHead walHead;
 } SVWriteMsg;
 
+typedef struct {
+  int32_t     startTime;
+  pthread_t * pthread;
+  tsem_t *    psem;
+  void *      param;
+} SWaitThread;
+
 // vnodeStatus
 extern char *vnodeStatus[];
 
@@ -96,6 +104,13 @@ int32_t vnodeWriteToRQueue(void *pVnode, void *pCont, int32_t contLen, int8_t qt
 void    vnodeFreeFromRQueue(void *pVnode, SVReadMsg *pRead);
 int32_t vnodeProcessRead(void *pVnode, SVReadMsg *pRead);
 
+// wait thread
+void vnodeAddWait(void* pVnode, pthread_t* pthread, tsem_t* psem, void* param);
+void vnodeRemoveWait(void* pVnode, void* param);
+// get wait thread count
+bool vnodeWaitTooMany(void* vparam);
+tsem_t* vnodeSemWait(void* vparam);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index 53101483099f40c1ce0cbbb1a94f20b46ca391af..5cc9a4a5888ae1bd421624a8c102cd6bcc814948 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -291,7 +291,20 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
     return;
   }
 
-  if (!tscIsUpdateQuery(pSql)) {  // select and show kinds of commands
+  if (tscIsDeleteQuery(pSql)) {
+    // delete
+    int numOfRows   = taos_affected_rows(pSql);
+    int numOfTables = taos_affected_tables(pSql);
+    int error_no    = taos_errno(pSql);
+
+    et = taosGetTimestampUs();
+    if (error_no == TSDB_CODE_SUCCESS) {
+      printf("Deleted %d row(s) from %d table(s) (%.6fs)\n", numOfRows, numOfTables, (et - st) / 1E6);
+    } else {
+      printf("Deleted interrupted (%s), %d row(s) from %d tables (%.6fs)\n", taos_errstr(pSql), numOfRows, numOfTables, (et - st) / 1E6);
+    }
+  }
+  else if (!tscIsUpdateQuery(pSql)) {  // select and show kinds of commands
     int error_no = 0;
 
     int numOfRows = shellDumpResult(pSql, fname, &error_no, printMode);
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index ad71a83a28f749b3b5584a8e8c73cb34bd8e40af..751a06ecb42e4f37ca857df6a1950ad169cadb71 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -352,7 +352,7 @@ void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVl
            pVgroup->pDb->dbCfgVersion, pVgroup->vgCfgVersion, pVgroup->numOfVnodes);
     mnodeSendAlterVgroupMsg(pVgroup,NULL);
   }
-  pVgroup->compact = pVload->compact; 
+  pVgroup->compact = pVload->compact;
 }
 
 static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) {
@@ -848,7 +848,6 @@ static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, v
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     *(int8_t *)pWrite = pVgroup->compact; 
     cols++;
-    
     mnodeDecVgroupRef(pVgroup);
     numOfRows++;
   }
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index 14ddb185d2a960483d5a932ec414240f48305663..8091a300b339839f4c0a91f54bc78b97b5bd858d 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -252,6 +252,12 @@ typedef struct SMiscInfo {
   };
 } SMiscInfo;
 
+typedef struct SDelData {
+  bool      existsCheck;
+  SStrToken tableName;
+  struct tSqlExpr* pWhere;
+} SDelData;
+
 typedef struct SSqlInfo {
   int32_t            type;
   bool               valid;
@@ -262,6 +268,7 @@ typedef struct SSqlInfo {
     SCreateTableSql *pCreateTableInfo;
     SAlterTableInfo *pAlterInfo;
     SMiscInfo       *pMiscInfo;
+    SDelData        *pDelData;
   };
 } SSqlInfo;
 
@@ -364,6 +371,9 @@ void tSetDbName(SStrToken *pCpxName, SStrToken *pDb);
 void tSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
 void tSetColumnType(TAOS_FIELD *pField, SStrToken *type);
 
+// malloc new SDelData and set with args
+SDelData *tGetDelData(SStrToken *pTableName, SStrToken* existsCheck, tSqlExpr* pWhere);
+
 /**
  *
  * @param yyp      The parser
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index a0519a1b483aefba65b168921a37c1eaa5eaa55e..e2649ca70e46168721e01179b1bdb1d227da19b7 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -985,7 +985,16 @@ cmd ::= KILL CONNECTION INTEGER(Y).   {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTIO
 cmd ::= KILL STREAM INTEGER(X) COLON(Z) INTEGER(Y).       {X.n += (Z.n + Y.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &X);}
 cmd ::= KILL QUERY INTEGER(X) COLON(Z) INTEGER(Y).        {X.n += (Z.n + Y.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &X);}
 
+//////////////////////////////////// DEL TRUNCATE TABLE /////////////////////////////////////
+
+//1 DELETE FROM TBNAME/STBNAME WHERE TS AND TAG CONDICTION
+cmd ::= DELETE FROM ifexists(Y) ids(X) cpxName(Z) where_opt(W). {
+  X.n += Z.n; 
+  SDelData * pDelData = tGetDelData(&X, &Y, W);
+  setSqlInfo(pInfo, pDelData, NULL, TSDB_SQL_DELETE_DATA);
+}
+
 %fallback ID ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT COPY DATABASE DEFERRED
   DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR GLOB IGNORE IMMEDIATE INITIALLY INSTEAD
   LIKE MATCH NMATCH KEY OF OFFSET RAISE REPLACE RESTRICT ROW STATEMENT TRIGGER VIEW ALL
-  NOW TODAY IPTOKEN SEMI NONE PREV LINEAR IMPORT TBNAME JOIN STABLE NULL INSERT INTO VALUES FILE.
+  NOW TODAY IPTOKEN SEMI NONE PREV LINEAR IMPORT TBNAME JOIN STABLE NULL INSERT INTO VALUES FILE.
\ No newline at end of file
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index fc7403152b2924e4d982c505e856f55712e8c4d7..54099e24eff457c2b3b3f4cb158d0afbac9f84e5 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -2453,6 +2453,9 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
 
   taosHashCleanup(pRuntimeEnv->pTableRetrieveTsMap);
   pRuntimeEnv->pTableRetrieveTsMap = NULL;
+  
+  taosHashCleanup(pRuntimeEnv->pTablesRead);
+  pRuntimeEnv->pTablesRead = NULL;
 
   taosHashCleanup(pRuntimeEnv->pResultRowListSet);
   pRuntimeEnv->pResultRowListSet = NULL;
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index 6b1573446d27d9c6c48413a3af48820b7ee7f971..b360fa95fc7c72c9c002c3d75e6fdc4296c0469a 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -1212,6 +1212,9 @@ void SqlInfoDestroy(SSqlInfo *pInfo) {
   taosArrayDestroy(&pInfo->funcs);
   if (pInfo->type == TSDB_SQL_SELECT) {
     destroyAllSqlNode(pInfo->list);
+  } else if (pInfo->type == TSDB_SQL_DELETE_DATA) {
+    tSqlExprDestroy(pInfo->pDelData->pWhere);
+    tfree(pInfo->pDelData);
   } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
     pInfo->pCreateTableInfo = destroyCreateTableSql(pInfo->pCreateTableInfo);
   } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
@@ -1474,3 +1477,15 @@ void setDefaultCreateTopicOption(SCreateDbInfo *pDBInfo) {
   pDBInfo->dbType = TSDB_DB_TYPE_TOPIC;
   pDBInfo->partitions = TSDB_DEFAULT_DB_PARTITON_OPTION;
 }
+
+// malloc new SDelData and set with args
+SDelData* tGetDelData(SStrToken* pTableName, SStrToken* existsCheck, tSqlExpr* pWhere) {
+  // malloc
+  SDelData* pDelData = (SDelData *) calloc(1, sizeof(SDelData));
+  // set value
+  pDelData->existsCheck = (existsCheck->n == 1);
+  pDelData->tableName   = *pTableName;
+  pDelData->pWhere      = pWhere;
+
+  return pDelData;
+}
\ No newline at end of file
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 44a3cb667cb4572d226c5b8a52ffb859cf27bfa3..dfa1d45d93521889e535417dd40aa99b20cb9c23 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -97,30 +97,30 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 292
+#define YYNOCODE 293
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  SLimitVal yy6;
-  SSqlNode* yy86;
-  tVariant yy110;
-  TAOS_FIELD yy115;
-  tSqlExpr* yy142;
-  SIntervalVal yy238;
-  SSessionWindowVal yy319;
-  SRelationInfo* yy328;
-  SRangeVal yy330;
-  SCreateDbInfo yy436;
-  SCreatedTableInfo yy480;
-  int32_t yy508;
-  SCreateAcctInfo yy517;
-  SArray* yy525;
-  int64_t yy543;
-  SWindowStateVal yy546;
-  SCreateTableSql* yy572;
-  int yy580;
+  tVariant yy42;
+  int32_t yy44;
+  SCreateTableSql* yy78;
+  SRangeVal yy132;
+  int yy133;
+  SSqlNode* yy144;
+  SLimitVal yy190;
+  tSqlExpr* yy194;
+  SIntervalVal yy200;
+  SSessionWindowVal yy235;
+  SWindowStateVal yy248;
+  TAOS_FIELD yy263;
+  int64_t yy277;
+  SCreateAcctInfo yy299;
+  SArray* yy333;
+  SCreateDbInfo yy342;
+  SCreatedTableInfo yy400;
+  SRelationInfo* yy516;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -130,17 +130,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             400
-#define YYNRULE              321
-#define YYNTOKEN             204
-#define YY_MAX_SHIFT         399
-#define YY_MIN_SHIFTREDUCE   627
-#define YY_MAX_SHIFTREDUCE   947
-#define YY_ERROR_ACTION      948
-#define YY_ACCEPT_ACTION     949
-#define YY_NO_ACTION         950
-#define YY_MIN_REDUCE        951
-#define YY_MAX_REDUCE        1271
+#define YYNSTATE             405
+#define YYNRULE              322
+#define YYNTOKEN             205
+#define YY_MAX_SHIFT         404
+#define YY_MIN_SHIFTREDUCE   633
+#define YY_MAX_SHIFTREDUCE   954
+#define YY_ERROR_ACTION      955
+#define YY_ACCEPT_ACTION     956
+#define YY_NO_ACTION         957
+#define YY_MIN_REDUCE        958
+#define YY_MAX_REDUCE        1279
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -206,322 +206,325 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (882)
+#define YY_ACTTAB_COUNT (889)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   219,  678, 1100,  164,  949,  399,   24,  762, 1134,  679,
- /*    10 */  1245,  678, 1247,  252,   38,   39, 1245,   42,   43,  679,
- /*    20 */  1110,  267,   31,   30,   29,  398,  245,   41,  349,   46,
- /*    30 */    44,   47,   45,   32,  109, 1109,  217,   37,   36,  374,
- /*    40 */   373,   35,   34,   33,   38,   39, 1245,   42,   43,  260,
- /*    50 */   179,  267,   31,   30,   29,  254, 1125,   41,  349,   46,
- /*    60 */    44,   47,   45,   32,   35,   34,   33,   37,   36,  306,
- /*    70 */  1094,   35,   34,   33,  290,  678,  297,  296,   38,   39,
- /*    80 */  1131,   42,   43,  679,  714,  267,   31,   30,   29,   60,
- /*    90 */    89,   41,  349,   46,   44,   47,   45,   32,  397,  395,
- /*   100 */   655,   37,   36,  218,  223,   35,   34,   33,   38,   39,
- /*   110 */    13,   42,   43, 1245, 1245,  267,   31,   30,   29,  224,
- /*   120 */    59,   41,  349,   46,   44,   47,   45,   32,  882, 1245,
- /*   130 */   885,   37,   36,  345,  247,   35,   34,   33,   60,   38,
- /*   140 */    40, 1107,   42,   43,  108,   87,  267,   31,   30,   29,
- /*   150 */   277,  876,   41,  349,   46,   44,   47,   45,   32,   86,
- /*   160 */    52,  186,   37,   36,  225,  678,   35,   34,   33,   39,
- /*   170 */   236,   42,   43,  679, 1245,  267,   31,   30,   29, 1236,
- /*   180 */  1245,   41,  349,   46,   44,   47,   45,   32,   60, 1245,
- /*   190 */  1106,   37,   36, 1091,   95,   35,   34,   33,   68,  343,
- /*   200 */   391,  390,  342,  341,  340,  389,  339,  338,  337,  388,
- /*   210 */   336,  387,  386,  628,  629,  630,  631,  632,  633,  634,
- /*   220 */   635,  636,  637,  638,  639,  640,  641,  161,  881,  246,
- /*   230 */   884,   42,   43,  257,   69,  267,   31,   30,   29, 1235,
- /*   240 */  1107,   41,  349,   46,   44,   47,   45,   32,  890, 1245,
- /*   250 */   384,   37,   36,   60, 1267,   35,   34,   33,   25, 1068,
- /*   260 */  1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
- /*   270 */  1066, 1067, 1069, 1070, 1125,  229, 1259,  239,  892,  836,
- /*   280 */   837,  880,  231,  883, 1186,  886, 1187,  316,  148,  147,
- /*   290 */   146,  230,  248,  239,  892,  357,   95,  880,  258,  883,
- /*   300 */  1184,  886, 1185,  264,  103, 1107,  102,   46,   44,   47,
- /*   310 */    45,   32, 1234,  243,  244,   37,   36,  351,  282,   35,
- /*   320 */    34,   33, 1245, 1092,    5,   63,  190,  286,  285,  243,
- /*   330 */   244,  189,  115,  120,  111,  119,   69,  790,  320,  101,
- /*   340 */   787,  100,  788,  298,  789,  132,  126,  137,  891,  353,
- /*   350 */   332,   60,  136,  106,  142,  145,  135,  259,  261,  289,
- /*   360 */   241,   85,   48,  139, 1110, 1110,  270,  215,  240,  277,
- /*   370 */  1245,  352,  272,  273,  210,  208,  206, 1245,   48, 1248,
- /*   380 */   187,  205,  152,  151,  150,  149, 1089, 1090,   56, 1093,
- /*   390 */   276,   68,  263,  391,  390,  277,  361,  268,  389,  893,
- /*   400 */   887,  889,  388, 1107,  387,  386,  350, 1076,   60, 1074,
- /*   410 */  1075,  345,   60,  104, 1077,  893,  887,  889, 1078,  299,
- /*   420 */  1079, 1080,  824,  348,  888,   32,  827,  134,   90,   37,
- /*   430 */    36,   60, 1197,   35,   34,   33, 1196,   37,   36,  384,
- /*   440 */   888,   35,   34,   33,   60,  347,  271, 1125,  269,   60,
- /*   450 */   360,  359,   60,  362,  302,  303,  219,  363,  791,  274,
- /*   460 */  1107,  219,  266,   60, 1107,  249, 1245,  808, 1248,  354,
- /*   470 */   278, 1245,  275, 1248,  369,  368,  364,  160,  158,  157,
- /*   480 */   242,  221,  222, 1107,    6,  226,  856,  277,  291,  370,
- /*   490 */  1245, 1245, 1245,  220,  371, 1245, 1107,  372, 1108,  227,
- /*   500 */   228, 1107,   61, 1245, 1107,  805,  233,  234,  376, 1245,
- /*   510 */  1245,  235,  232,  999,  216, 1107, 1245, 1245, 1009, 1000,
- /*   520 */   200, 1245, 1245,   92, 1245,  200,  200,  392, 1037,    1,
- /*   530 */   188,    3,  201,   93,   10,  301,  300,  833,  843,  844,
- /*   540 */   347,  250,   77,   80,  772,  324,  855,  774,  326,  265,
- /*   550 */   773,  166,   72,   49,  922,  812,  894,  319,   61,   61,
- /*   560 */    55,   72,  107,  293,   72,  677,   84,   15,    9,   14,
- /*   570 */     9,  182,  125,  293,  124,   17,  897,   16,  797,    9,
- /*   580 */   798,  795,  287,  796,  366,  365,   81,   78,   19,  879,
- /*   590 */    18,  255,  131,  327,  130,  144,  143,   21,  761,   20,
- /*   600 */  1193, 1192,  256,  375,  162,   26,  163, 1126,  294, 1105,
- /*   610 */  1133,  181, 1144, 1176, 1141, 1142, 1146,  165, 1175,  170,
- /*   620 */   312, 1174, 1101, 1173,  159,  183, 1123, 1099,  184,  823,
- /*   630 */   185, 1014,  329,  173,  330,  331,  334,  335,   70,  213,
- /*   640 */    66,  346,  305,  251, 1008,  358,  307, 1266,  309,   82,
- /*   650 */   122,  171, 1265,   79, 1262,  191,  367,  321,  172,   28,
- /*   660 */   174, 1258,  128, 1257,  317,  315, 1254,  313,  311,  192,
- /*   670 */   308, 1034,   67,   62,  304,   71,   88,  214,  996,  138,
- /*   680 */   994,  178,  140,  141,  992,  175,  991,   27,  279,  203,
- /*   690 */   204,  988,  987,  986,  985,  984,  983,  982,  207,  209,
- /*   700 */   333,  974,  211,  971,  212,  385,  967,  378,  133,  292,
- /*   710 */  1103,   91,   96,  377,  310,  379,  380,  381,  382,  383,
- /*   720 */   393,   83,  947,  281,  262,  328,  280,  946,  283,  284,
- /*   730 */   945,  928,  927,  237,  288,  238,  116, 1013,  293, 1012,
- /*   740 */   117,  323,   11,   94,  800,   53,  295,   97,  832,   75,
- /*   750 */   830,  990,  826,  195,  194, 1035,  153,  193,  989,  197,
- /*   760 */   196,  198,  199,  154,  981,  829,  155,  322, 1072, 1036,
- /*   770 */   980,  825,  156,  973,   54,  176,  177,  180,  972,    2,
- /*   780 */    76,    4,  834,  167, 1082,  845,  168,  169,  839,   98,
- /*   790 */   253,  841,   99,  314,   64,  352,  318,   65,  105,   22,
- /*   800 */    12,   23,   50,  325,   57,   51,  113,  108,  110,  692,
- /*   810 */   112,  727,   58,  114,  725,  724,  723,  721,  720,  719,
- /*   820 */   716,  344,  682,  118,    7,  919,  917,  896,  920,  895,
- /*   830 */   918,    8,  898,  356,  355,   73,  121,  123,   61,   74,
- /*   840 */   794,  764,  763,  127,  129,  760,  708,  706,  698,  704,
- /*   850 */   700,  702,  793,  696,  694,  730,  729,  728,  726,  722,
- /*   860 */   718,  717,  202,  680,  645,  951,  654,  652,  950,  394,
- /*   870 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
- /*   880 */   950,  396,
+ /*     0 */   223,  684, 1107,  168,  956,  404,   24,  768, 1141,  685,
+ /*    10 */  1252,  684, 1254,  256,   38,   39, 1252,   42,   43,  685,
+ /*    20 */  1117,  271,   31,   30,   29,  403,  249,   41,  354,   46,
+ /*    30 */    44,   47,   45,   32,  110,  258,  221,   37,   36,  379,
+ /*    40 */   378,   35,   34,   33,   38,   39, 1252,   42,   43,  264,
+ /*    50 */   183,  271,   31,   30,   29,  303, 1132,   41,  354,   46,
+ /*    60 */    44,   47,   45,   32,   35,   34,   33,   37,   36,  311,
+ /*    70 */  1101,   35,   34,   33,  295,  684,  302,  301,   38,   39,
+ /*    80 */  1138,   42,   43,  685,  720,  271,   31,   30,   29,   60,
+ /*    90 */    90,   41,  354,   46,   44,   47,   45,   32,  402,  400,
+ /*   100 */   661,   37,   36,  222,  227,   35,   34,   33,   38,   39,
+ /*   110 */    13,   42,   43, 1252, 1252,  271,   31,   30,   29,  296,
+ /*   120 */    59,   41,  354,   46,   44,   47,   45,   32,  161,  159,
+ /*   130 */   158,   37,   36,   61,  251,   35,   34,   33,  350,   38,
+ /*   140 */    40, 1114,   42,   43,  109,   88,  271,   31,   30,   29,
+ /*   150 */   281,  882,   41,  354,   46,   44,   47,   45,   32,  389,
+ /*   160 */    52,  190,   37,   36,  228,  684,   35,   34,   33,   39,
+ /*   170 */   229,   42,   43,  685, 1252,  271,   31,   30,   29,  240,
+ /*   180 */  1252,   41,  354,   46,   44,   47,   45,   32,   60, 1252,
+ /*   190 */    96,   37,   36,  842,  843,   35,   34,   33,   68,  348,
+ /*   200 */   396,  395,  347,  346,  345,  394,  344,  343,  342,  393,
+ /*   210 */   341,  392,  391,  634,  635,  636,  637,  638,  639,  640,
+ /*   220 */   641,  642,  643,  644,  645,  646,  647,  162,   60,  250,
+ /*   230 */    69,   42,   43,  261, 1116,  271,   31,   30,   29,  287,
+ /*   240 */  1114,   41,  354,   46,   44,   47,   45,   32,  291,  290,
+ /*   250 */   811,   37,   36,   60, 1274,   35,   34,   33,   25,  352,
+ /*   260 */  1075, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071,
+ /*   270 */  1072, 1073, 1074, 1076, 1077,  233,  324,  243,  898,   10,
+ /*   280 */  1113,  886,  235,  889, 1193,  892, 1194,  321,  149,  148,
+ /*   290 */   147,  234, 1243,  243,  898,  362,   96,  886,  262,  889,
+ /*   300 */   304,  892, 1252,  359, 1191, 1114, 1192,   46,   44,   47,
+ /*   310 */    45,   32, 1242,  247,  248,   37,   36,  356, 1241,   35,
+ /*   320 */    34,   33, 1252, 1204,    5,   63,  194,  245, 1252,  247,
+ /*   330 */   248,  193,  116,  121,  112,  120,   69, 1252,  796,  325,
+ /*   340 */   102,  793,  101,  794,   32,  795, 1266,  830,   37,   36,
+ /*   350 */   337,  833,   35,   34,   33, 1099,  214,  212,  210,  294,
+ /*   360 */    60,   86,   48,  209,  153,  152,  151,  150,  244,  274,
+ /*   370 */   268,  267,  284,  276,  277,  133,  127,  138,   48,  307,
+ /*   380 */   308,  888,  137,  891,  143,  146,  136,  280,  272,  887,
+ /*   390 */   104,  890,  103,  140,  246, 1083, 1203, 1081, 1082,  899,
+ /*   400 */   893,  895, 1084,  107, 1252,  366, 1085,  263, 1086, 1087,
+ /*   410 */   903,   60, 1114,  259, 1117,  899,  893,  895,   68,  353,
+ /*   420 */   396,  395,   37,   36,  894,  394,   35,   34,   33,  393,
+ /*   430 */    60,  392,  391,   60,  219,  223, 1096, 1097,   56, 1100,
+ /*   440 */   894,  352,   60,  350, 1252, 1252, 1255, 1255,  186,  275,
+ /*   450 */    60,  273,  223,  365,  364,   60,  367,  281,  270,  797,
+ /*   460 */   278,   60, 1252, 1114, 1255,  814,  254,  282,  191,  279,
+ /*   470 */   265,  374,  373,  281,  164,  368,  225, 1117,  369,  226,
+ /*   480 */     6,  230, 1114,  224,  355, 1114, 1252,  375,  231, 1252,
+ /*   490 */    87, 1252,  281, 1252, 1114,  376,  862, 1006, 1252,   93,
+ /*   500 */   377,  896, 1114, 1115,  204,  232,  381, 1114,  135,  897,
+ /*   510 */   105,  237,  238, 1114, 1132, 1252,  239,  236,  220, 1132,
+ /*   520 */   389, 1252, 1252,   94, 1098,   91, 1252, 1252, 1252,  397,
+ /*   530 */  1044, 1016,  252, 1007,  839,    1,  192,  253,  204,  298,
+ /*   540 */   204,    3,  205,  306,  305,  849,  850,   77,  170,  269,
+ /*   550 */   778,   80,  329,  818,  780,  331,  861,  779,   55,   72,
+ /*   560 */    49,  928,  358,  298,   61,  900,   61,  683,   72,  108,
+ /*   570 */    15,   72,   14,   84,  126,    9,  125,  292,   17,    9,
+ /*   580 */    16,    9,  371,  370,  357,  803,  801,  804,  802,  885,
+ /*   590 */   166,  332,   78,   19,   81,   18,  132,   21,  131,   20,
+ /*   600 */   145,  144, 1200,  167, 1199,  767,  260,  380, 1112, 1140,
+ /*   610 */    26, 1151, 1148, 1149, 1153, 1133,  169,  174,  299,  317,
+ /*   620 */  1108, 1183, 1182, 1181,  185, 1180,  187, 1106,  188, 1279,
+ /*   630 */   189, 1021,  160,  829,  398,  334,  335,  336,  339,  340,
+ /*   640 */    70,  217,   66,  351,   27, 1015,  363, 1273, 1130,  123,
+ /*   650 */  1272,  310,   82, 1269,  255,  312,  195,  372,  314, 1265,
+ /*   660 */   129, 1264, 1261,  196, 1041,   67,   79,  175,   62,   71,
+ /*   670 */   218,  326, 1003,   28,  139,  176,  322, 1001,  178,  141,
+ /*   680 */   320,  142,  177,  999,  998,  283,  318,  207,  316,  208,
+ /*   690 */   995,  994,  993,  992,  991,  313,  990,  989,  211,  213,
+ /*   700 */   981,  215,  978,  216,  974,  309,   89,  338,  163,  390,
+ /*   710 */    85,  297, 1110,   92,   97,  315,  134,  382,  383,  384,
+ /*   720 */   385,  386,  387,   83,  388,  165,  266,  333,  953,  286,
+ /*   730 */   285,  952,  288,  241,  242,  289,  951,  934,  933, 1020,
+ /*   740 */  1019,  117,  118,  293,  298,  328,   11,   95,  806,  300,
+ /*   750 */   997,   53,  996,  199,  154,  198, 1042,  197,  200,  202,
+ /*   760 */   201,  203,  838,  155,  156,  988,  987,    2,  157, 1079,
+ /*   770 */   179,  327, 1043,  980,  979,  184,  180,    4,  181,  182,
+ /*   780 */    54,   98,   75,  836,  835, 1089,  832,  831,   76,  173,
+ /*   790 */   840,  171,  257,  851,  172,   64,  845,   99,  357,  847,
+ /*   800 */   100,  319,  323,   22,   12,   65,   23,  106,   50,  330,
+ /*   810 */   111,   51,  109,  114,  698,  733,  731,  730,   57,  113,
+ /*   820 */   729,  727,  726,   58,  115,  725,  722,  688,  119,  349,
+ /*   830 */     7,  925,  923,  926,  902,  901,  924,  361,    8,  904,
+ /*   840 */   122,  124,  360,   73,   61,  800,  799,   74,  128,  770,
+ /*   850 */   130,  769,  766,  714,  712,  704,  710,  706,  708,  702,
+ /*   860 */   700,  736,  735,  734,  732,  728,  724,  723,  206,  686,
+ /*   870 */   958,  651,  660,  957,  658,  957,  957,  957,  957,  957,
+ /*   880 */   957,  957,  957,  957,  957,  957,  399,  957,  401,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   278,    1,  207,  207,  205,  206,  278,    5,  207,    9,
- /*    10 */   288,    1,  290,  253,   14,   15,  288,   17,   18,    9,
- /*    20 */   260,   21,   22,   23,   24,  207,  208,   27,   28,   29,
- /*    30 */    30,   31,   32,   33,  215,  260,  278,   37,   38,   37,
- /*    40 */    38,   41,   42,   43,   14,   15,  288,   17,   18,  254,
- /*    50 */   265,   21,   22,   23,   24,    1,  257,   27,   28,   29,
- /*    60 */    30,   31,   32,   33,   41,   42,   43,   37,   38,  284,
- /*    70 */   251,   41,   42,   43,  275,    1,  280,  281,   14,   15,
- /*    80 */   279,   17,   18,    9,    5,   21,   22,   23,   24,  207,
+ /*     0 */   279,    1,  208,  208,  206,  207,  279,    5,  208,    9,
+ /*    10 */   289,    1,  291,  254,   14,   15,  289,   17,   18,    9,
+ /*    20 */   261,   21,   22,   23,   24,  208,  209,   27,   28,   29,
+ /*    30 */    30,   31,   32,   33,  216,    1,  279,   37,   38,   37,
+ /*    40 */    38,   41,   42,   43,   14,   15,  289,   17,   18,  255,
+ /*    50 */   266,   21,   22,   23,   24,  284,  258,   27,   28,   29,
+ /*    60 */    30,   31,   32,   33,   41,   42,   43,   37,   38,  285,
+ /*    70 */   252,   41,   42,   43,  276,    1,  281,  282,   14,   15,
+ /*    80 */   280,   17,   18,    9,    5,   21,   22,   23,   24,  208,
  /*    90 */    90,   27,   28,   29,   30,   31,   32,   33,   69,   70,
- /*   100 */    71,   37,   38,  278,  278,   41,   42,   43,   14,   15,
- /*   110 */    86,   17,   18,  288,  288,   21,   22,   23,   24,  278,
- /*   120 */    90,   27,   28,   29,   30,   31,   32,   33,    5,  288,
- /*   130 */     7,   37,   38,   88,  252,   41,   42,   43,  207,   14,
- /*   140 */    15,  259,   17,   18,  120,  121,   21,   22,   23,   24,
- /*   150 */   207,   87,   27,   28,   29,   30,   31,   32,   33,  215,
- /*   160 */    86,  218,   37,   38,  278,    1,   41,   42,   43,   15,
- /*   170 */   278,   17,   18,    9,  288,   21,   22,   23,   24,  278,
- /*   180 */   288,   27,   28,   29,   30,   31,   32,   33,  207,  288,
- /*   190 */   259,   37,   38,  249,   86,   41,   42,   43,  102,  103,
+ /*   100 */    71,   37,   38,  279,  279,   41,   42,   43,   14,   15,
+ /*   110 */    86,   17,   18,  289,  289,   21,   22,   23,   24,   87,
+ /*   120 */    90,   27,   28,   29,   30,   31,   32,   33,   66,   67,
+ /*   130 */    68,   37,   38,  101,  253,   41,   42,   43,   88,   14,
+ /*   140 */    15,  260,   17,   18,  120,  121,   21,   22,   23,   24,
+ /*   150 */   208,   87,   27,   28,   29,   30,   31,   32,   33,   94,
+ /*   160 */    86,  219,   37,   38,  279,    1,   41,   42,   43,   15,
+ /*   170 */   279,   17,   18,    9,  289,   21,   22,   23,   24,  279,
+ /*   180 */   289,   27,   28,   29,   30,   31,   32,   33,  208,  289,
+ /*   190 */    86,   37,   38,  132,  133,   41,   42,   43,  102,  103,
  /*   200 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
  /*   210 */   114,  115,  116,   49,   50,   51,   52,   53,   54,   55,
- /*   220 */    56,   57,   58,   59,   60,   61,   62,   63,    5,   65,
- /*   230 */     7,   17,   18,  252,  126,   21,   22,   23,   24,  278,
- /*   240 */   259,   27,   28,   29,   30,   31,   32,   33,  125,  288,
- /*   250 */    94,   37,   38,  207,  260,   41,   42,   43,   48,  231,
+ /*   220 */    56,   57,   58,   59,   60,   61,   62,   63,  208,   65,
+ /*   230 */   126,   17,   18,  253,  261,   21,   22,   23,   24,  150,
+ /*   240 */   260,   27,   28,   29,   30,   31,   32,   33,  159,  160,
+ /*   250 */   101,   37,   38,  208,  261,   41,   42,   43,   48,   47,
  /*   260 */   232,  233,  234,  235,  236,  237,  238,  239,  240,  241,
- /*   270 */   242,  243,  244,  245,  257,   65,  260,    1,    2,  132,
- /*   280 */   133,    5,   72,    7,  286,    9,  288,  289,   78,   79,
- /*   290 */    80,   81,  275,    1,    2,   85,   86,    5,  252,    7,
- /*   300 */   286,    9,  288,  214,  286,  259,  288,   29,   30,   31,
- /*   310 */    32,   33,  278,   37,   38,   37,   38,   41,  150,   41,
- /*   320 */    42,   43,  288,    0,   66,   67,   68,  159,  160,   37,
- /*   330 */    38,   73,   74,   75,   76,   77,  126,    2,  285,  286,
- /*   340 */     5,  288,    7,  283,    9,   66,   67,   68,  125,   25,
- /*   350 */    92,  207,   73,  215,   75,   76,   77,  253,  253,  149,
- /*   360 */   278,  151,   86,   84,  260,  260,   72,  278,  158,  207,
- /*   370 */   288,   47,   37,   38,   66,   67,   68,  288,   86,  290,
- /*   380 */   218,   73,   74,   75,   76,   77,  248,  249,  250,  251,
- /*   390 */    72,  102,  214,  104,  105,  207,  252,  214,  109,  123,
- /*   400 */   124,  125,  113,  259,  115,  116,  218,  231,  207,  233,
- /*   410 */   234,   88,  207,  261,  238,  123,  124,  125,  242,  283,
- /*   420 */   244,  245,    5,   25,  148,   33,    9,   82,  276,   37,
- /*   430 */    38,  207,  247,   41,   42,   43,  247,   37,   38,   94,
- /*   440 */   148,   41,   42,   43,  207,   47,  152,  257,  154,  207,
- /*   450 */   156,  157,  207,  252,   37,   38,  278,  252,  123,  124,
- /*   460 */   259,  278,   64,  207,  259,  275,  288,   41,  290,   16,
- /*   470 */   152,  288,  154,  290,  156,  157,  252,   66,   67,   68,
- /*   480 */   278,  278,  278,  259,   86,  278,   80,  207,   87,  252,
- /*   490 */   288,  288,  288,  278,  252,  288,  259,  252,  218,  278,
- /*   500 */   278,  259,  101,  288,  259,  101,  278,  278,  252,  288,
- /*   510 */   288,  278,  278,  213,  278,  259,  288,  288,  213,  213,
- /*   520 */   220,  288,  288,   87,  288,  220,  220,  229,  230,  216,
- /*   530 */   217,  211,  212,   87,  130,   37,   38,   87,   87,   87,
- /*   540 */    47,  124,  101,  101,   87,   87,  140,   87,   87,    1,
- /*   550 */    87,  101,  101,  101,   87,  129,   87,   64,  101,  101,
- /*   560 */    86,  101,  101,  127,  101,   87,   86,  153,  101,  155,
- /*   570 */   101,  255,  153,  127,  155,  153,  123,  155,    5,  101,
- /*   580 */     7,    5,  207,    7,   37,   38,  144,  146,  153,   41,
- /*   590 */   155,  247,  153,  119,  155,   82,   83,  153,  118,  155,
- /*   600 */   247,  247,  247,  247,  207,  277,  207,  257,  257,  207,
- /*   610 */   207,  262,  207,  287,  207,  207,  207,  207,  287,  207,
- /*   620 */   207,  287,  257,  287,   64,  207,  274,  207,  207,  125,
- /*   630 */   207,  207,  207,  271,  207,  207,  207,  207,  207,  207,
- /*   640 */   207,  207,  282,  282,  207,  207,  282,  207,  282,  143,
- /*   650 */   207,  273,  207,  145,  207,  207,  207,  138,  272,  142,
- /*   660 */   270,  207,  207,  207,  141,  136,  207,  135,  134,  207,
- /*   670 */   137,  207,  207,  207,  131,  207,  122,  207,  207,  207,
- /*   680 */   207,  266,  207,  207,  207,  269,  207,  147,  207,  207,
- /*   690 */   207,  207,  207,  207,  207,  207,  207,  207,  207,  207,
- /*   700 */    93,  207,  207,  207,  207,  117,  207,   55,  100,  209,
- /*   710 */   209,  209,  209,   99,  209,   96,   98,   59,   97,   95,
- /*   720 */    88,  209,    5,    5,  209,  209,  161,    5,  161,    5,
- /*   730 */     5,  104,  103,  209,  150,  209,  215,  219,  127,  219,
- /*   740 */   215,  119,   86,  128,   87,   86,  101,  101,   87,  101,
- /*   750 */   125,  209,    5,  222,  226,  228,  210,  227,  209,  223,
- /*   760 */   225,  224,  221,  210,  209,  125,  210,  256,  246,  230,
- /*   770 */   209,    5,  210,  209,  264,  268,  267,  263,  209,  216,
- /*   780 */    86,  211,   87,   86,  246,   87,   86,  101,   87,   86,
- /*   790 */     1,   87,   86,   86,  101,   47,    1,  101,   90,  139,
- /*   800 */    86,  139,   86,  119,   91,   86,   74,  120,   82,    5,
- /*   810 */    90,    9,   91,   90,    5,    5,    5,    5,    5,    5,
- /*   820 */     5,   16,   89,   82,   86,    9,    9,   87,    9,   87,
- /*   830 */     9,   86,  123,   63,   28,   17,  155,  155,  101,   17,
- /*   840 */   125,    5,    5,  155,  155,   87,    5,    5,    5,    5,
- /*   850 */     5,    5,  125,    5,    5,    5,    5,    5,    5,    5,
- /*   860 */     5,    5,  101,   89,   64,    0,    9,    9,  291,   22,
- /*   870 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   880 */   291,   22,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   890 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   900 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   910 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   920 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   930 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   940 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   950 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   960 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   970 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   980 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*   990 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1000 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1010 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1020 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1030 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1040 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1050 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1060 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1070 */   291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
- /*  1080 */   291,  291,  291,  291,  291,  291,
+ /*   270 */   242,  243,  244,  245,  246,   65,   64,    1,    2,  130,
+ /*   280 */   260,    5,   72,    7,  287,    9,  289,  290,   78,   79,
+ /*   290 */    80,   81,  279,    1,    2,   85,   86,    5,  253,    7,
+ /*   300 */   284,    9,  289,   16,  287,  260,  289,   29,   30,   31,
+ /*   310 */    32,   33,  279,   37,   38,   37,   38,   41,  279,   41,
+ /*   320 */    42,   43,  289,  248,   66,   67,   68,  279,  289,   37,
+ /*   330 */    38,   73,   74,   75,   76,   77,  126,  289,    2,  286,
+ /*   340 */   287,    5,  289,    7,   33,    9,  261,    5,   37,   38,
+ /*   350 */    92,    9,   41,   42,   43,    0,   66,   67,   68,  149,
+ /*   360 */   208,  151,   86,   73,   74,   75,   76,   77,  158,   72,
+ /*   370 */   215,  215,  162,   37,   38,   66,   67,   68,   86,   37,
+ /*   380 */    38,    5,   73,    7,   75,   76,   77,   72,  215,    5,
+ /*   390 */   287,    7,  289,   84,  279,  232,  248,  234,  235,  123,
+ /*   400 */   124,  125,  239,  216,  289,  253,  243,  254,  245,  246,
+ /*   410 */   123,  208,  260,  248,  261,  123,  124,  125,  102,   25,
+ /*   420 */   104,  105,   37,   38,  148,  109,   41,   42,   43,  113,
+ /*   430 */   208,  115,  116,  208,  279,  279,  249,  250,  251,  252,
+ /*   440 */   148,   47,  208,   88,  289,  289,  291,  291,  256,  152,
+ /*   450 */   208,  154,  279,  156,  157,  208,  253,  208,   64,  123,
+ /*   460 */   124,  208,  289,  260,  291,   41,  124,  152,  219,  154,
+ /*   470 */   254,  156,  157,  208,  208,  253,  279,  261,  253,  279,
+ /*   480 */    86,  279,  260,  279,  219,  260,  289,  253,  279,  289,
+ /*   490 */   216,  289,  208,  289,  260,  253,   80,  214,  289,   87,
+ /*   500 */   253,  125,  260,  219,  221,  279,  253,  260,   82,  125,
+ /*   510 */   262,  279,  279,  260,  258,  289,  279,  279,  279,  258,
+ /*   520 */    94,  289,  289,   87,  250,  277,  289,  289,  289,  230,
+ /*   530 */   231,  214,  276,  214,   87,  217,  218,  276,  221,  127,
+ /*   540 */   221,  212,  213,   37,   38,   87,   87,  101,  101,    1,
+ /*   550 */    87,  101,   87,  129,   87,   87,  140,   87,   86,  101,
+ /*   560 */   101,   87,   25,  127,  101,   87,  101,   87,  101,  101,
+ /*   570 */   153,  101,  155,   86,  153,  101,  155,  208,  153,  101,
+ /*   580 */   155,  101,   37,   38,   47,    5,    5,    7,    7,   41,
+ /*   590 */   208,  119,  146,  153,  144,  155,  153,  153,  155,  155,
+ /*   600 */    82,   83,  248,  208,  248,  118,  248,  248,  208,  208,
+ /*   610 */   278,  208,  208,  208,  208,  258,  208,  208,  258,  208,
+ /*   620 */   258,  288,  288,  288,  263,  288,  208,  208,  208,  264,
+ /*   630 */   208,  208,   64,  125,   88,  208,  208,  208,  208,  208,
+ /*   640 */   208,  208,  208,  208,  147,  208,  208,  208,  275,  208,
+ /*   650 */   208,  283,  143,  208,  283,  283,  208,  208,  283,  208,
+ /*   660 */   208,  208,  208,  208,  208,  208,  145,  274,  208,  208,
+ /*   670 */   208,  138,  208,  142,  208,  273,  141,  208,  271,  208,
+ /*   680 */   136,  208,  272,  208,  208,  208,  135,  208,  134,  208,
+ /*   690 */   208,  208,  208,  208,  208,  137,  208,  208,  208,  208,
+ /*   700 */   208,  208,  208,  208,  208,  131,  122,   93,  210,  117,
+ /*   710 */   211,  210,  210,  210,  210,  210,  100,   99,   55,   96,
+ /*   720 */    98,   59,   97,  210,   95,  130,  210,  210,    5,    5,
+ /*   730 */   161,    5,  161,  210,  210,    5,    5,  104,  103,  220,
+ /*   740 */   220,  216,  216,  150,  127,  119,   86,  128,   87,  101,
+ /*   750 */   210,   86,  210,  223,  211,  227,  229,  228,  226,  225,
+ /*   760 */   224,  222,   87,  211,  211,  210,  210,  217,  211,  247,
+ /*   770 */   270,  257,  231,  210,  210,  264,  269,  212,  268,  267,
+ /*   780 */   265,  101,  101,  125,  125,  247,    5,    5,   86,  101,
+ /*   790 */    87,   86,    1,   87,   86,  101,   87,   86,   47,   87,
+ /*   800 */    86,   86,    1,  139,   86,  101,  139,   90,   86,  119,
+ /*   810 */    82,   86,  120,   74,    5,    9,    5,    5,   91,   90,
+ /*   820 */     5,    5,    5,   91,   90,    5,    5,   89,   82,   16,
+ /*   830 */    86,    9,    9,    9,   87,   87,    9,   63,   86,  123,
+ /*   840 */   155,  155,   28,   17,  101,  125,  125,   17,  155,    5,
+ /*   850 */   155,    5,   87,    5,    5,    5,    5,    5,    5,    5,
+ /*   860 */     5,    5,    5,    5,    5,    5,    5,    5,  101,   89,
+ /*   870 */     0,   64,    9,  292,    9,  292,  292,  292,  292,  292,
+ /*   880 */   292,  292,  292,  292,  292,  292,   22,  292,   22,  292,
+ /*   890 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   900 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   910 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   920 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   930 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   940 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   950 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   960 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   970 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   980 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*   990 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1000 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1010 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1020 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1030 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1040 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1050 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1060 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1070 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1080 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
+ /*  1090 */   292,  292,  292,  292,
 };
-#define YY_SHIFT_COUNT    (399)
+#define YY_SHIFT_COUNT    (404)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (865)
+#define YY_SHIFT_MAX      (870)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   210,   96,   96,  289,  289,   45,  276,  292,  292,  292,
+ /*     0 */   210,   96,   96,  316,  316,   50,  276,  292,  292,  292,
  /*    10 */    74,   10,   10,   10,   10,   10,   10,   10,   10,   10,
- /*    20 */    10,   10,   54,   54,    0,  164,  292,  292,  292,  292,
+ /*    20 */    10,   10,   34,   34,    0,  164,  292,  292,  292,  292,
  /*    30 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
- /*    40 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  335,
- /*    50 */   335,  335,  108,  108,  147,   10,  323,   10,   10,   10,
- /*    60 */    10,   10,  345,   45,   54,   54,  156,  156,   79,  882,
- /*    70 */   882,  882,  335,  335,  335,  417,  417,    2,    2,    2,
+ /*    40 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  336,
+ /*    50 */   336,  336,  104,  104,   61,   10,  355,   10,   10,   10,
+ /*    60 */    10,   10,  426,   50,   34,   34,   65,   65,   79,  889,
+ /*    70 */   889,  889,  336,  336,  336,  342,  342,    2,    2,    2,
  /*    80 */     2,    2,    2,   24,    2,   10,   10,   10,   10,   10,
- /*    90 */   426,   10,   10,   10,  108,  108,   10,   10,   10,   10,
- /*   100 */   406,  406,  406,  406,  404,  108,   10,   10,   10,   10,
+ /*    90 */    10,  424,   10,   10,   10,  104,  104,   10,   10,   10,
+ /*   100 */    10,  416,  416,  416,  416,  149,  104,   10,   10,   10,
  /*   110 */    10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  /*   120 */    10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  /*   130 */    10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  /*   140 */    10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  /*   150 */    10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
- /*   160 */    10,   10,  560,  560,  560,  560,  504,  504,  504,  504,
- /*   170 */   560,  506,  508,  519,  517,  523,  529,  532,  534,  533,
- /*   180 */   543,  540,  554,  560,  560,  560,  607,  607,  588,   45,
- /*   190 */    45,  560,  560,  608,  614,  652,  619,  618,  658,  621,
- /*   200 */   624,  588,   79,  560,  560,  632,  632,  560,  632,  560,
- /*   210 */   632,  560,  560,  882,  882,   30,   64,   94,   94,   94,
- /*   220 */   125,  154,  214,  278,  278,  278,  278,  278,  278,  258,
- /*   230 */   279,  308,  392,  392,  392,  392,  400,  294,  318,  398,
- /*   240 */   168,   23,   23,  123,  223,   29,  411,  401,  436,  446,
- /*   250 */   498,  450,  451,  452,  493,  441,  442,  457,  458,  460,
- /*   260 */   461,  463,  474,  467,  469,  324,  548,  453,  478,  414,
- /*   270 */   419,  422,  573,  576,  547,  435,  439,  480,  444,  513,
- /*   280 */   717,  565,  718,  722,  567,  724,  725,  627,  629,  584,
- /*   290 */   611,  622,  656,  615,  657,  659,  645,  646,  661,  648,
- /*   300 */   625,  640,  747,  766,  694,  695,  697,  698,  700,  701,
- /*   310 */   686,  703,  704,  706,  789,  707,  693,  660,  748,  795,
- /*   320 */   696,  662,  708,  714,  622,  716,  684,  719,  687,  726,
- /*   330 */   713,  720,  732,  804,  721,  723,  802,  809,  810,  811,
- /*   340 */   812,  813,  814,  815,  733,  805,  741,  816,  817,  738,
- /*   350 */   740,  742,  819,  821,  709,  745,  806,  770,  818,  681,
- /*   360 */   682,  737,  737,  737,  737,  715,  727,  822,  688,  689,
- /*   370 */   737,  737,  737,  836,  837,  758,  737,  841,  842,  843,
- /*   380 */   844,  845,  846,  848,  849,  850,  851,  852,  853,  854,
- /*   390 */   855,  856,  761,  774,  857,  847,  858,  859,  800,  865,
+ /*   160 */    10,   10,   10,  497,  568,  546,  568,  568,  568,  568,
+ /*   170 */   508,  508,  508,  508,  568,  509,  521,  533,  531,  535,
+ /*   180 */   544,  551,  554,  558,  574,  497,  584,  568,  568,  568,
+ /*   190 */   614,  614,  592,   50,   50,  568,  568,  616,  618,  663,
+ /*   200 */   623,  622,  662,  625,  629,  592,   79,  568,  568,  546,
+ /*   210 */   546,  568,  546,  568,  546,  568,  568,  889,  889,   30,
+ /*   220 */    64,   94,   94,   94,  125,  154,  214,  278,  278,  278,
+ /*   230 */   278,  278,  278,  258,  309,  290,  311,  311,  311,  311,
+ /*   240 */   385,  297,  315,  394,   89,   23,   23,  376,  384,   29,
+ /*   250 */    62,   32,  412,  436,  506,  447,  458,  459,  212,  446,
+ /*   260 */   450,  463,  465,  467,  468,  470,  472,  474,  478,  537,
+ /*   270 */   548,  287,  480,  417,  421,  425,  580,  581,  545,  440,
+ /*   280 */   443,  487,  444,  518,  595,  723,  569,  724,  726,  571,
+ /*   290 */   730,  731,  633,  635,  593,  617,  626,  660,  619,  661,
+ /*   300 */   665,  648,  680,  675,  681,  658,  659,  781,  782,  702,
+ /*   310 */   703,  705,  706,  708,  709,  688,  711,  712,  714,  791,
+ /*   320 */   715,  694,  664,  751,  801,  704,  667,  717,  718,  626,
+ /*   330 */   722,  690,  725,  692,  728,  727,  729,  739,  809,  732,
+ /*   340 */   734,  806,  811,  812,  815,  816,  817,  820,  821,  738,
+ /*   350 */   813,  746,  822,  823,  744,  747,  748,  824,  827,  716,
+ /*   360 */   752,  814,  774,  826,  685,  686,  743,  743,  743,  743,
+ /*   370 */   720,  721,  830,  693,  695,  743,  743,  743,  844,  846,
+ /*   380 */   765,  743,  848,  849,  850,  851,  852,  853,  854,  855,
+ /*   390 */   856,  857,  858,  859,  860,  861,  862,  767,  780,  863,
+ /*   400 */   864,  865,  866,  807,  870,
 };
-#define YY_REDUCE_COUNT (214)
-#define YY_REDUCE_MIN   (-278)
-#define YY_REDUCE_MAX   (570)
+#define YY_REDUCE_COUNT (218)
+#define YY_REDUCE_MIN   (-279)
+#define YY_REDUCE_MAX   (565)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -201,   28,   28,  176,  176,  138,   89,  178,  183, -278,
- /*    10 */  -204, -118,  -19,   46,  144,  201,  205,  224,  237,  242,
- /*    20 */   245,  256,   -2,   53, -199, -182, -272, -242, -175, -174,
- /*    30 */  -159, -114, -108,  -99,  -39,   34,   82,  202,  203,  204,
- /*    40 */   207,  215,  221,  222,  228,  229,  233,  234,  236, -240,
- /*    50 */   104,  105,   17,  190, -215, -205, -181,  -57,  162,  188,
- /*    60 */   280,  -69,  300,  -56,   14,   18,  305,  306,  298,  152,
- /*    70 */   313,  320, -225,   -6,   16,   60,  136,  185,  189,  344,
- /*    80 */   353,  354,  355,  316,  356,  375,  397,  399,  402,  403,
- /*    90 */   328,  405,  407,  408,  350,  351,  409,  410,  412,  413,
- /*   100 */   326,  331,  334,  336,  349,  365,  418,  420,  421,  423,
- /*   110 */   424,  425,  427,  428,  429,  430,  431,  432,  433,  434,
- /*   120 */   437,  438,  440,  443,  445,  447,  448,  449,  454,  455,
- /*   130 */   456,  459,  462,  464,  465,  466,  468,  470,  471,  472,
- /*   140 */   473,  475,  476,  477,  479,  481,  482,  483,  484,  485,
- /*   150 */   486,  487,  488,  489,  490,  491,  492,  494,  495,  496,
- /*   160 */   497,  499,  500,  501,  502,  503,  360,  361,  364,  366,
- /*   170 */   505,  352,  378,  386,  362,  390,  416,  507,  509,  415,
- /*   180 */   510,  514,  511,  512,  515,  516,  518,  520,  522,  521,
- /*   190 */   525,  524,  526,  527,  530,  528,  531,  535,  536,  537,
- /*   200 */   541,  538,  539,  542,  549,  546,  553,  555,  556,  561,
- /*   210 */   562,  564,  569,  563,  570,
+ /*     0 */  -202,   28,   28,  163,  163,  187,  155,  156,  173, -279,
+ /*    10 */  -205, -119,  -20,   45,  152,  203,  222,  225,  234,  242,
+ /*    20 */   247,  253,   -3,   53, -200, -183, -273, -243, -176, -175,
+ /*    30 */  -115, -109, -100,   13,   33,   39,   48,  115,  197,  200,
+ /*    40 */   202,  204,  209,  226,  232,  233,  237,  238,  239, -241,
+ /*    50 */   153,  216,  256,  261, -216, -206, -182,  -58,  249,  265,
+ /*    60 */   284,   20,  283,  274,   17,  103,  317,  319,  299,  248,
+ /*    70 */   318,  329,  -27,   -7,   85, -229,   16,   75,  148,  165,
+ /*    80 */   354,  356,  358,  192,  359,  266,  369,  382,  395,  400,
+ /*    90 */   401,  332,  403,  404,  405,  357,  360,  406,  408,  409,
+ /*   100 */   411,  333,  334,  335,  337,  361,  362,  418,  419,  420,
+ /*   110 */   422,  423,  427,  428,  429,  430,  431,  432,  433,  434,
+ /*   120 */   435,  437,  438,  439,  441,  442,  445,  448,  449,  451,
+ /*   130 */   452,  453,  454,  455,  456,  457,  460,  461,  462,  464,
+ /*   140 */   466,  469,  471,  473,  475,  476,  477,  479,  481,  482,
+ /*   150 */   483,  484,  485,  486,  488,  489,  490,  491,  492,  493,
+ /*   160 */   494,  495,  496,  365,  498,  499,  501,  502,  503,  504,
+ /*   170 */   368,  371,  372,  375,  505,  373,  393,  402,  410,  407,
+ /*   180 */   500,  507,  510,  512,  515,  511,  514,  513,  516,  517,
+ /*   190 */   519,  520,  522,  525,  526,  523,  524,  527,  529,  528,
+ /*   200 */   530,  532,  536,  534,  539,  538,  541,  540,  542,  543,
+ /*   210 */   552,  555,  553,  556,  557,  563,  564,  550,  565,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   948, 1071, 1010, 1081,  997, 1007, 1250, 1250, 1250, 1250,
- /*    10 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*    20 */   948,  948,  948,  948, 1135,  968,  948,  948,  948,  948,
- /*    30 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*    40 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*    50 */   948,  948,  948,  948, 1159,  948, 1007,  948,  948,  948,
- /*    60 */   948,  948, 1017, 1007,  948,  948, 1017, 1017,  948, 1130,
- /*    70 */  1055, 1073,  948,  948,  948,  948,  948,  948,  948,  948,
- /*    80 */   948,  948,  948, 1102,  948,  948,  948,  948,  948,  948,
- /*    90 */  1137, 1143, 1140,  948,  948,  948, 1145,  948,  948,  948,
- /*   100 */  1181, 1181, 1181, 1181, 1128,  948,  948,  948,  948,  948,
- /*   110 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   120 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   130 */   948,  948,  948,  948,  948,  948,  948,  948,  995,  948,
- /*   140 */   993,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   150 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   160 */   948,  966,  970,  970,  970,  970,  948,  948,  948,  948,
- /*   170 */   970, 1190, 1194, 1171, 1188, 1182, 1166, 1164, 1162, 1170,
- /*   180 */  1155, 1198, 1104,  970,  970,  970, 1015, 1015, 1011, 1007,
- /*   190 */  1007,  970,  970, 1033, 1031, 1029, 1021, 1027, 1023, 1025,
- /*   200 */  1019,  998,  948,  970,  970, 1005, 1005,  970, 1005,  970,
- /*   210 */  1005,  970,  970, 1055, 1073, 1249,  948, 1199, 1189, 1249,
- /*   220 */   948, 1231, 1230, 1240, 1239, 1238, 1229, 1228, 1227,  948,
- /*   230 */   948,  948, 1223, 1226, 1225, 1224, 1237,  948,  948, 1201,
- /*   240 */   948, 1233, 1232,  948,  948,  948,  948,  948,  948,  948,
- /*   250 */  1152,  948,  948,  948, 1177, 1195, 1191,  948,  948,  948,
- /*   260 */   948,  948,  948,  948,  948, 1202,  948,  948,  948,  948,
- /*   270 */   948,  948,  948,  948, 1116,  948,  948, 1083,  948,  948,
- /*   280 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   290 */  1127,  948,  948,  948,  948,  948, 1139, 1138,  948,  948,
- /*   300 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   310 */   948,  948,  948,  948,  948,  948, 1183,  948, 1178,  948,
- /*   320 */  1172,  948,  948,  948, 1095,  948,  948,  948,  948,  948,
- /*   330 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   340 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   350 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   360 */   948, 1268, 1263, 1264, 1261,  948,  948,  948,  948,  948,
- /*   370 */  1260, 1255, 1256,  948,  948,  948, 1253,  948,  948,  948,
- /*   380 */   948,  948,  948,  948,  948,  948,  948,  948,  948,  948,
- /*   390 */   948,  948, 1039,  948,  948,  977,  948,  975,  948,  948,
+ /*     0 */   955, 1078, 1017, 1088, 1004, 1014, 1257, 1257, 1257, 1257,
+ /*    10 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*    20 */   955,  955,  955,  955, 1142,  975,  955,  955,  955,  955,
+ /*    30 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*    40 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*    50 */   955,  955,  955,  955, 1166,  955, 1014,  955,  955,  955,
+ /*    60 */   955,  955, 1024, 1014,  955,  955, 1024, 1024,  955, 1137,
+ /*    70 */  1062, 1080,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*    80 */   955,  955,  955, 1109,  955,  955,  955,  955,  955,  955,
+ /*    90 */   955, 1144, 1150, 1147,  955,  955,  955, 1152,  955,  955,
+ /*   100 */   955, 1188, 1188, 1188, 1188, 1135,  955,  955,  955,  955,
+ /*   110 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   120 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   130 */   955,  955,  955,  955,  955,  955,  955,  955,  955, 1002,
+ /*   140 */   955, 1000,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   150 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   160 */   955,  955,  973, 1205,  977, 1012,  977,  977,  977,  977,
+ /*   170 */   955,  955,  955,  955,  977, 1197, 1201, 1178, 1195, 1189,
+ /*   180 */  1173, 1171, 1169, 1177, 1162, 1205, 1111,  977,  977,  977,
+ /*   190 */  1022, 1022, 1018, 1014, 1014,  977,  977, 1040, 1038, 1036,
+ /*   200 */  1028, 1034, 1030, 1032, 1026, 1005,  955,  977,  977, 1012,
+ /*   210 */  1012,  977, 1012,  977, 1012,  977,  977, 1062, 1080, 1256,
+ /*   220 */   955, 1206, 1196, 1256,  955, 1238, 1237, 1247, 1246, 1245,
+ /*   230 */  1236, 1235, 1234,  955,  955,  955, 1230, 1233, 1232, 1231,
+ /*   240 */  1244,  955,  955, 1208,  955, 1240, 1239,  955,  955,  955,
+ /*   250 */   955,  955,  955,  955, 1159,  955,  955,  955, 1184, 1202,
+ /*   260 */  1198,  955,  955,  955,  955,  955,  955,  955,  955, 1209,
+ /*   270 */   955,  955,  955,  955,  955,  955,  955,  955, 1123,  955,
+ /*   280 */   955, 1090,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   290 */   955,  955,  955,  955,  955, 1134,  955,  955,  955,  955,
+ /*   300 */   955, 1146, 1145,  955,  955,  955,  955,  955,  955,  955,
+ /*   310 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   320 */   955, 1190,  955, 1185,  955, 1179,  955,  955,  955, 1102,
+ /*   330 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   340 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   350 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   360 */   955,  955,  955,  955,  955,  955, 1275, 1270, 1271, 1268,
+ /*   370 */   955,  955,  955,  955,  955, 1267, 1262, 1263,  955,  955,
+ /*   380 */   955, 1260,  955,  955,  955,  955,  955,  955,  955,  955,
+ /*   390 */   955,  955,  955,  955,  955,  955,  955, 1046,  955,  955,
+ /*   400 */   984,  955,  982,  955,  955,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -703,6 +706,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /* CONNECTION => nothing */
     0,  /*     STREAM => nothing */
     0,  /*      COLON => nothing */
+    0,  /*     DELETE => nothing */
     1,  /*      ABORT => ID */
     1,  /*      AFTER => ID */
     1,  /*     ATTACH => ID */
@@ -993,135 +997,136 @@ static const char *const yyTokenName[] = {
   /*  159 */ "CONNECTION",
   /*  160 */ "STREAM",
   /*  161 */ "COLON",
-  /*  162 */ "ABORT",
-  /*  163 */ "AFTER",
-  /*  164 */ "ATTACH",
-  /*  165 */ "BEFORE",
-  /*  166 */ "BEGIN",
-  /*  167 */ "CASCADE",
-  /*  168 */ "CLUSTER",
-  /*  169 */ "CONFLICT",
-  /*  170 */ "COPY",
-  /*  171 */ "DEFERRED",
-  /*  172 */ "DELIMITERS",
-  /*  173 */ "DETACH",
-  /*  174 */ "EACH",
-  /*  175 */ "END",
-  /*  176 */ "EXPLAIN",
-  /*  177 */ "FAIL",
-  /*  178 */ "FOR",
-  /*  179 */ "IGNORE",
-  /*  180 */ "IMMEDIATE",
-  /*  181 */ "INITIALLY",
-  /*  182 */ "INSTEAD",
-  /*  183 */ "KEY",
-  /*  184 */ "OF",
-  /*  185 */ "RAISE",
-  /*  186 */ "REPLACE",
-  /*  187 */ "RESTRICT",
-  /*  188 */ "ROW",
-  /*  189 */ "STATEMENT",
-  /*  190 */ "TRIGGER",
-  /*  191 */ "VIEW",
-  /*  192 */ "IPTOKEN",
-  /*  193 */ "SEMI",
-  /*  194 */ "NONE",
-  /*  195 */ "PREV",
-  /*  196 */ "LINEAR",
-  /*  197 */ "IMPORT",
-  /*  198 */ "TBNAME",
-  /*  199 */ "JOIN",
-  /*  200 */ "INSERT",
-  /*  201 */ "INTO",
-  /*  202 */ "VALUES",
-  /*  203 */ "FILE",
-  /*  204 */ "error",
-  /*  205 */ "program",
-  /*  206 */ "cmd",
-  /*  207 */ "ids",
-  /*  208 */ "dbPrefix",
-  /*  209 */ "cpxName",
-  /*  210 */ "ifexists",
-  /*  211 */ "alter_db_optr",
-  /*  212 */ "alter_topic_optr",
-  /*  213 */ "acct_optr",
-  /*  214 */ "exprlist",
-  /*  215 */ "ifnotexists",
-  /*  216 */ "db_optr",
-  /*  217 */ "topic_optr",
-  /*  218 */ "typename",
-  /*  219 */ "bufsize",
-  /*  220 */ "pps",
-  /*  221 */ "tseries",
-  /*  222 */ "dbs",
-  /*  223 */ "streams",
-  /*  224 */ "storage",
-  /*  225 */ "qtime",
-  /*  226 */ "users",
-  /*  227 */ "conns",
-  /*  228 */ "state",
-  /*  229 */ "intitemlist",
-  /*  230 */ "intitem",
-  /*  231 */ "keep",
-  /*  232 */ "cache",
-  /*  233 */ "replica",
-  /*  234 */ "quorum",
-  /*  235 */ "days",
-  /*  236 */ "minrows",
-  /*  237 */ "maxrows",
-  /*  238 */ "blocks",
-  /*  239 */ "ctime",
-  /*  240 */ "wal",
-  /*  241 */ "fsync",
-  /*  242 */ "comp",
-  /*  243 */ "prec",
-  /*  244 */ "update",
-  /*  245 */ "cachelast",
-  /*  246 */ "partitions",
-  /*  247 */ "signed",
-  /*  248 */ "create_table_args",
-  /*  249 */ "create_stable_args",
-  /*  250 */ "create_table_list",
-  /*  251 */ "create_from_stable",
-  /*  252 */ "columnlist",
-  /*  253 */ "tagitemlist",
-  /*  254 */ "tagNamelist",
-  /*  255 */ "to_opt",
-  /*  256 */ "split_opt",
-  /*  257 */ "select",
-  /*  258 */ "to_split",
-  /*  259 */ "column",
-  /*  260 */ "tagitem",
-  /*  261 */ "selcollist",
-  /*  262 */ "from",
-  /*  263 */ "where_opt",
-  /*  264 */ "range_option",
-  /*  265 */ "interval_option",
-  /*  266 */ "sliding_opt",
-  /*  267 */ "session_option",
-  /*  268 */ "windowstate_option",
-  /*  269 */ "fill_opt",
-  /*  270 */ "groupby_opt",
-  /*  271 */ "having_opt",
-  /*  272 */ "orderby_opt",
-  /*  273 */ "slimit_opt",
-  /*  274 */ "limit_opt",
-  /*  275 */ "union",
-  /*  276 */ "sclp",
-  /*  277 */ "distinct",
-  /*  278 */ "expr",
-  /*  279 */ "as",
-  /*  280 */ "tablelist",
-  /*  281 */ "sub",
-  /*  282 */ "tmvar",
-  /*  283 */ "timestamp",
-  /*  284 */ "intervalKey",
-  /*  285 */ "sortlist",
-  /*  286 */ "item",
-  /*  287 */ "sortorder",
-  /*  288 */ "arrow",
-  /*  289 */ "grouplist",
-  /*  290 */ "expritem",
+  /*  162 */ "DELETE",
+  /*  163 */ "ABORT",
+  /*  164 */ "AFTER",
+  /*  165 */ "ATTACH",
+  /*  166 */ "BEFORE",
+  /*  167 */ "BEGIN",
+  /*  168 */ "CASCADE",
+  /*  169 */ "CLUSTER",
+  /*  170 */ "CONFLICT",
+  /*  171 */ "COPY",
+  /*  172 */ "DEFERRED",
+  /*  173 */ "DELIMITERS",
+  /*  174 */ "DETACH",
+  /*  175 */ "EACH",
+  /*  176 */ "END",
+  /*  177 */ "EXPLAIN",
+  /*  178 */ "FAIL",
+  /*  179 */ "FOR",
+  /*  180 */ "IGNORE",
+  /*  181 */ "IMMEDIATE",
+  /*  182 */ "INITIALLY",
+  /*  183 */ "INSTEAD",
+  /*  184 */ "KEY",
+  /*  185 */ "OF",
+  /*  186 */ "RAISE",
+  /*  187 */ "REPLACE",
+  /*  188 */ "RESTRICT",
+  /*  189 */ "ROW",
+  /*  190 */ "STATEMENT",
+  /*  191 */ "TRIGGER",
+  /*  192 */ "VIEW",
+  /*  193 */ "IPTOKEN",
+  /*  194 */ "SEMI",
+  /*  195 */ "NONE",
+  /*  196 */ "PREV",
+  /*  197 */ "LINEAR",
+  /*  198 */ "IMPORT",
+  /*  199 */ "TBNAME",
+  /*  200 */ "JOIN",
+  /*  201 */ "INSERT",
+  /*  202 */ "INTO",
+  /*  203 */ "VALUES",
+  /*  204 */ "FILE",
+  /*  205 */ "error",
+  /*  206 */ "program",
+  /*  207 */ "cmd",
+  /*  208 */ "ids",
+  /*  209 */ "dbPrefix",
+  /*  210 */ "cpxName",
+  /*  211 */ "ifexists",
+  /*  212 */ "alter_db_optr",
+  /*  213 */ "alter_topic_optr",
+  /*  214 */ "acct_optr",
+  /*  215 */ "exprlist",
+  /*  216 */ "ifnotexists",
+  /*  217 */ "db_optr",
+  /*  218 */ "topic_optr",
+  /*  219 */ "typename",
+  /*  220 */ "bufsize",
+  /*  221 */ "pps",
+  /*  222 */ "tseries",
+  /*  223 */ "dbs",
+  /*  224 */ "streams",
+  /*  225 */ "storage",
+  /*  226 */ "qtime",
+  /*  227 */ "users",
+  /*  228 */ "conns",
+  /*  229 */ "state",
+  /*  230 */ "intitemlist",
+  /*  231 */ "intitem",
+  /*  232 */ "keep",
+  /*  233 */ "cache",
+  /*  234 */ "replica",
+  /*  235 */ "quorum",
+  /*  236 */ "days",
+  /*  237 */ "minrows",
+  /*  238 */ "maxrows",
+  /*  239 */ "blocks",
+  /*  240 */ "ctime",
+  /*  241 */ "wal",
+  /*  242 */ "fsync",
+  /*  243 */ "comp",
+  /*  244 */ "prec",
+  /*  245 */ "update",
+  /*  246 */ "cachelast",
+  /*  247 */ "partitions",
+  /*  248 */ "signed",
+  /*  249 */ "create_table_args",
+  /*  250 */ "create_stable_args",
+  /*  251 */ "create_table_list",
+  /*  252 */ "create_from_stable",
+  /*  253 */ "columnlist",
+  /*  254 */ "tagitemlist",
+  /*  255 */ "tagNamelist",
+  /*  256 */ "to_opt",
+  /*  257 */ "split_opt",
+  /*  258 */ "select",
+  /*  259 */ "to_split",
+  /*  260 */ "column",
+  /*  261 */ "tagitem",
+  /*  262 */ "selcollist",
+  /*  263 */ "from",
+  /*  264 */ "where_opt",
+  /*  265 */ "range_option",
+  /*  266 */ "interval_option",
+  /*  267 */ "sliding_opt",
+  /*  268 */ "session_option",
+  /*  269 */ "windowstate_option",
+  /*  270 */ "fill_opt",
+  /*  271 */ "groupby_opt",
+  /*  272 */ "having_opt",
+  /*  273 */ "orderby_opt",
+  /*  274 */ "slimit_opt",
+  /*  275 */ "limit_opt",
+  /*  276 */ "union",
+  /*  277 */ "sclp",
+  /*  278 */ "distinct",
+  /*  279 */ "expr",
+  /*  280 */ "as",
+  /*  281 */ "tablelist",
+  /*  282 */ "sub",
+  /*  283 */ "tmvar",
+  /*  284 */ "timestamp",
+  /*  285 */ "intervalKey",
+  /*  286 */ "sortlist",
+  /*  287 */ "item",
+  /*  288 */ "sortorder",
+  /*  289 */ "arrow",
+  /*  290 */ "grouplist",
+  /*  291 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1450,6 +1455,7 @@ static const char *const yyRuleName[] = {
  /* 318 */ "cmd ::= KILL CONNECTION INTEGER",
  /* 319 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
  /* 320 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 321 */ "cmd ::= DELETE FROM ifexists ids cpxName where_opt",
 };
 #endif /* NDEBUG */
 
@@ -1570,57 +1576,57 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 214: /* exprlist */
-    case 261: /* selcollist */
-    case 276: /* sclp */
+    case 215: /* exprlist */
+    case 262: /* selcollist */
+    case 277: /* sclp */
 {
-tSqlExprListDestroy((yypminor->yy525));
+tSqlExprListDestroy((yypminor->yy333));
 }
       break;
-    case 229: /* intitemlist */
-    case 231: /* keep */
-    case 252: /* columnlist */
-    case 253: /* tagitemlist */
-    case 254: /* tagNamelist */
-    case 269: /* fill_opt */
-    case 270: /* groupby_opt */
-    case 272: /* orderby_opt */
-    case 285: /* sortlist */
-    case 289: /* grouplist */
-{
-taosArrayDestroy(&(yypminor->yy525));
+    case 230: /* intitemlist */
+    case 232: /* keep */
+    case 253: /* columnlist */
+    case 254: /* tagitemlist */
+    case 255: /* tagNamelist */
+    case 270: /* fill_opt */
+    case 271: /* groupby_opt */
+    case 273: /* orderby_opt */
+    case 286: /* sortlist */
+    case 290: /* grouplist */
+{
+taosArrayDestroy(&(yypminor->yy333));
 }
       break;
-    case 250: /* create_table_list */
+    case 251: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy572));
+destroyCreateTableSql((yypminor->yy78));
 }
       break;
-    case 257: /* select */
+    case 258: /* select */
 {
-destroySqlNode((yypminor->yy86));
+destroySqlNode((yypminor->yy144));
 }
       break;
-    case 262: /* from */
-    case 280: /* tablelist */
-    case 281: /* sub */
+    case 263: /* from */
+    case 281: /* tablelist */
+    case 282: /* sub */
 {
-destroyRelationInfo((yypminor->yy328));
+destroyRelationInfo((yypminor->yy516));
 }
       break;
-    case 263: /* where_opt */
-    case 271: /* having_opt */
-    case 278: /* expr */
-    case 283: /* timestamp */
-    case 288: /* arrow */
-    case 290: /* expritem */
+    case 264: /* where_opt */
+    case 272: /* having_opt */
+    case 279: /* expr */
+    case 284: /* timestamp */
+    case 289: /* arrow */
+    case 291: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy142));
+tSqlExprDestroy((yypminor->yy194));
 }
       break;
-    case 275: /* union */
+    case 276: /* union */
 {
-destroyAllSqlNode((yypminor->yy525));
+destroyAllSqlNode((yypminor->yy333));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1914,327 +1920,328 @@ static const struct {
   YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
   signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
 } yyRuleInfo[] = {
-  {  205,   -1 }, /* (0) program ::= cmd */
-  {  206,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  206,   -2 }, /* (2) cmd ::= SHOW TOPICS */
-  {  206,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
-  {  206,   -2 }, /* (4) cmd ::= SHOW MNODES */
-  {  206,   -2 }, /* (5) cmd ::= SHOW DNODES */
-  {  206,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
-  {  206,   -2 }, /* (7) cmd ::= SHOW USERS */
-  {  206,   -2 }, /* (8) cmd ::= SHOW MODULES */
-  {  206,   -2 }, /* (9) cmd ::= SHOW QUERIES */
-  {  206,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
-  {  206,   -2 }, /* (11) cmd ::= SHOW STREAMS */
-  {  206,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
-  {  206,   -2 }, /* (13) cmd ::= SHOW SCORES */
-  {  206,   -2 }, /* (14) cmd ::= SHOW GRANTS */
-  {  206,   -2 }, /* (15) cmd ::= SHOW VNODES */
-  {  206,   -3 }, /* (16) cmd ::= SHOW VNODES ids */
-  {  208,    0 }, /* (17) dbPrefix ::= */
-  {  208,   -2 }, /* (18) dbPrefix ::= ids DOT */
-  {  209,    0 }, /* (19) cpxName ::= */
-  {  209,   -2 }, /* (20) cpxName ::= DOT ids */
-  {  206,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
-  {  206,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
-  {  206,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
-  {  206,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
-  {  206,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
-  {  206,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
-  {  206,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
-  {  206,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
-  {  206,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  206,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
-  {  206,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
-  {  206,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
-  {  206,   -3 }, /* (33) cmd ::= DROP FUNCTION ids */
-  {  206,   -3 }, /* (34) cmd ::= DROP DNODE ids */
-  {  206,   -3 }, /* (35) cmd ::= DROP USER ids */
-  {  206,   -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
-  {  206,   -2 }, /* (37) cmd ::= USE ids */
-  {  206,   -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
-  {  206,   -3 }, /* (39) cmd ::= DESC ids cpxName */
-  {  206,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
-  {  206,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  206,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
-  {  206,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
-  {  206,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
-  {  206,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
-  {  206,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  206,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
-  {  206,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  206,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  206,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
-  {  207,   -1 }, /* (51) ids ::= ID */
-  {  207,   -1 }, /* (52) ids ::= STRING */
-  {  210,   -2 }, /* (53) ifexists ::= IF EXISTS */
-  {  210,    0 }, /* (54) ifexists ::= */
-  {  215,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
-  {  215,    0 }, /* (56) ifnotexists ::= */
-  {  206,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
-  {  206,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  206,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  206,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
-  {  206,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  206,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  206,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
-  {  219,    0 }, /* (64) bufsize ::= */
-  {  219,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
-  {  220,    0 }, /* (66) pps ::= */
-  {  220,   -2 }, /* (67) pps ::= PPS INTEGER */
-  {  221,    0 }, /* (68) tseries ::= */
-  {  221,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
-  {  222,    0 }, /* (70) dbs ::= */
-  {  222,   -2 }, /* (71) dbs ::= DBS INTEGER */
-  {  223,    0 }, /* (72) streams ::= */
-  {  223,   -2 }, /* (73) streams ::= STREAMS INTEGER */
-  {  224,    0 }, /* (74) storage ::= */
-  {  224,   -2 }, /* (75) storage ::= STORAGE INTEGER */
-  {  225,    0 }, /* (76) qtime ::= */
-  {  225,   -2 }, /* (77) qtime ::= QTIME INTEGER */
-  {  226,    0 }, /* (78) users ::= */
-  {  226,   -2 }, /* (79) users ::= USERS INTEGER */
-  {  227,    0 }, /* (80) conns ::= */
-  {  227,   -2 }, /* (81) conns ::= CONNS INTEGER */
-  {  228,    0 }, /* (82) state ::= */
-  {  228,   -2 }, /* (83) state ::= STATE ids */
-  {  213,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  229,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
-  {  229,   -1 }, /* (86) intitemlist ::= intitem */
-  {  230,   -1 }, /* (87) intitem ::= INTEGER */
-  {  231,   -2 }, /* (88) keep ::= KEEP intitemlist */
-  {  232,   -2 }, /* (89) cache ::= CACHE INTEGER */
-  {  233,   -2 }, /* (90) replica ::= REPLICA INTEGER */
-  {  234,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
-  {  235,   -2 }, /* (92) days ::= DAYS INTEGER */
-  {  236,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
-  {  237,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
-  {  238,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
-  {  239,   -2 }, /* (96) ctime ::= CTIME INTEGER */
-  {  240,   -2 }, /* (97) wal ::= WAL INTEGER */
-  {  241,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
-  {  242,   -2 }, /* (99) comp ::= COMP INTEGER */
-  {  243,   -2 }, /* (100) prec ::= PRECISION STRING */
-  {  244,   -2 }, /* (101) update ::= UPDATE INTEGER */
-  {  245,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
-  {  246,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
-  {  216,    0 }, /* (104) db_optr ::= */
-  {  216,   -2 }, /* (105) db_optr ::= db_optr cache */
-  {  216,   -2 }, /* (106) db_optr ::= db_optr replica */
-  {  216,   -2 }, /* (107) db_optr ::= db_optr quorum */
-  {  216,   -2 }, /* (108) db_optr ::= db_optr days */
-  {  216,   -2 }, /* (109) db_optr ::= db_optr minrows */
-  {  216,   -2 }, /* (110) db_optr ::= db_optr maxrows */
-  {  216,   -2 }, /* (111) db_optr ::= db_optr blocks */
-  {  216,   -2 }, /* (112) db_optr ::= db_optr ctime */
-  {  216,   -2 }, /* (113) db_optr ::= db_optr wal */
-  {  216,   -2 }, /* (114) db_optr ::= db_optr fsync */
-  {  216,   -2 }, /* (115) db_optr ::= db_optr comp */
-  {  216,   -2 }, /* (116) db_optr ::= db_optr prec */
-  {  216,   -2 }, /* (117) db_optr ::= db_optr keep */
-  {  216,   -2 }, /* (118) db_optr ::= db_optr update */
-  {  216,   -2 }, /* (119) db_optr ::= db_optr cachelast */
-  {  217,   -1 }, /* (120) topic_optr ::= db_optr */
-  {  217,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
-  {  211,    0 }, /* (122) alter_db_optr ::= */
-  {  211,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
-  {  211,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
-  {  211,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
-  {  211,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
-  {  211,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
-  {  211,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
-  {  211,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
-  {  212,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
-  {  212,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
-  {  218,   -1 }, /* (132) typename ::= ids */
-  {  218,   -4 }, /* (133) typename ::= ids LP signed RP */
-  {  218,   -2 }, /* (134) typename ::= ids UNSIGNED */
-  {  247,   -1 }, /* (135) signed ::= INTEGER */
-  {  247,   -2 }, /* (136) signed ::= PLUS INTEGER */
-  {  247,   -2 }, /* (137) signed ::= MINUS INTEGER */
-  {  206,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
-  {  206,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
-  {  206,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
-  {  206,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
-  {  250,   -1 }, /* (142) create_table_list ::= create_from_stable */
-  {  250,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
-  {  248,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  249,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  251,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  251,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
-  {  254,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
-  {  254,   -1 }, /* (149) tagNamelist ::= ids */
-  {  248,   -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
-  {  255,    0 }, /* (151) to_opt ::= */
-  {  255,   -3 }, /* (152) to_opt ::= TO ids cpxName */
-  {  256,    0 }, /* (153) split_opt ::= */
-  {  256,   -2 }, /* (154) split_opt ::= SPLIT ids */
-  {  252,   -3 }, /* (155) columnlist ::= columnlist COMMA column */
-  {  252,   -1 }, /* (156) columnlist ::= column */
-  {  259,   -2 }, /* (157) column ::= ids typename */
-  {  253,   -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  253,   -1 }, /* (159) tagitemlist ::= tagitem */
-  {  260,   -1 }, /* (160) tagitem ::= INTEGER */
-  {  260,   -1 }, /* (161) tagitem ::= FLOAT */
-  {  260,   -1 }, /* (162) tagitem ::= STRING */
-  {  260,   -1 }, /* (163) tagitem ::= BOOL */
-  {  260,   -1 }, /* (164) tagitem ::= NULL */
-  {  260,   -1 }, /* (165) tagitem ::= NOW */
-  {  260,   -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */
-  {  260,   -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */
-  {  260,   -2 }, /* (168) tagitem ::= MINUS INTEGER */
-  {  260,   -2 }, /* (169) tagitem ::= MINUS FLOAT */
-  {  260,   -2 }, /* (170) tagitem ::= PLUS INTEGER */
-  {  260,   -2 }, /* (171) tagitem ::= PLUS FLOAT */
-  {  257,  -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-  {  257,   -3 }, /* (173) select ::= LP select RP */
-  {  275,   -1 }, /* (174) union ::= select */
-  {  275,   -4 }, /* (175) union ::= union UNION ALL select */
-  {  206,   -1 }, /* (176) cmd ::= union */
-  {  257,   -2 }, /* (177) select ::= SELECT selcollist */
-  {  276,   -2 }, /* (178) sclp ::= selcollist COMMA */
-  {  276,    0 }, /* (179) sclp ::= */
-  {  261,   -4 }, /* (180) selcollist ::= sclp distinct expr as */
-  {  261,   -2 }, /* (181) selcollist ::= sclp STAR */
-  {  279,   -2 }, /* (182) as ::= AS ids */
-  {  279,   -1 }, /* (183) as ::= ids */
-  {  279,    0 }, /* (184) as ::= */
-  {  277,   -1 }, /* (185) distinct ::= DISTINCT */
-  {  277,    0 }, /* (186) distinct ::= */
-  {  262,   -2 }, /* (187) from ::= FROM tablelist */
-  {  262,   -2 }, /* (188) from ::= FROM sub */
-  {  281,   -3 }, /* (189) sub ::= LP union RP */
-  {  281,   -4 }, /* (190) sub ::= LP union RP ids */
-  {  281,   -6 }, /* (191) sub ::= sub COMMA LP union RP ids */
-  {  280,   -2 }, /* (192) tablelist ::= ids cpxName */
-  {  280,   -3 }, /* (193) tablelist ::= ids cpxName ids */
-  {  280,   -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */
-  {  280,   -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  282,   -1 }, /* (196) tmvar ::= VARIABLE */
-  {  283,   -1 }, /* (197) timestamp ::= INTEGER */
-  {  283,   -2 }, /* (198) timestamp ::= MINUS INTEGER */
-  {  283,   -2 }, /* (199) timestamp ::= PLUS INTEGER */
-  {  283,   -1 }, /* (200) timestamp ::= STRING */
-  {  283,   -1 }, /* (201) timestamp ::= NOW */
-  {  283,   -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */
-  {  283,   -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */
-  {  264,    0 }, /* (204) range_option ::= */
-  {  264,   -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */
-  {  265,   -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */
-  {  265,   -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-  {  265,    0 }, /* (208) interval_option ::= */
-  {  284,   -1 }, /* (209) intervalKey ::= INTERVAL */
-  {  284,   -1 }, /* (210) intervalKey ::= EVERY */
-  {  267,    0 }, /* (211) session_option ::= */
-  {  267,   -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-  {  268,    0 }, /* (213) windowstate_option ::= */
-  {  268,   -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */
-  {  269,    0 }, /* (215) fill_opt ::= */
-  {  269,   -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  269,   -4 }, /* (217) fill_opt ::= FILL LP ID RP */
-  {  266,   -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */
-  {  266,    0 }, /* (219) sliding_opt ::= */
-  {  272,    0 }, /* (220) orderby_opt ::= */
-  {  272,   -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */
-  {  285,   -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */
-  {  285,   -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */
-  {  285,   -2 }, /* (224) sortlist ::= item sortorder */
-  {  285,   -2 }, /* (225) sortlist ::= arrow sortorder */
-  {  286,   -1 }, /* (226) item ::= ID */
-  {  286,   -3 }, /* (227) item ::= ID DOT ID */
-  {  287,   -1 }, /* (228) sortorder ::= ASC */
-  {  287,   -1 }, /* (229) sortorder ::= DESC */
-  {  287,    0 }, /* (230) sortorder ::= */
-  {  270,    0 }, /* (231) groupby_opt ::= */
-  {  270,   -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */
-  {  289,   -3 }, /* (233) grouplist ::= grouplist COMMA item */
-  {  289,   -3 }, /* (234) grouplist ::= grouplist COMMA arrow */
-  {  289,   -1 }, /* (235) grouplist ::= item */
-  {  289,   -1 }, /* (236) grouplist ::= arrow */
-  {  271,    0 }, /* (237) having_opt ::= */
-  {  271,   -2 }, /* (238) having_opt ::= HAVING expr */
-  {  274,    0 }, /* (239) limit_opt ::= */
-  {  274,   -2 }, /* (240) limit_opt ::= LIMIT signed */
-  {  274,   -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */
-  {  274,   -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */
-  {  273,    0 }, /* (243) slimit_opt ::= */
-  {  273,   -2 }, /* (244) slimit_opt ::= SLIMIT signed */
-  {  273,   -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  273,   -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  263,    0 }, /* (247) where_opt ::= */
-  {  263,   -2 }, /* (248) where_opt ::= WHERE expr */
-  {  278,   -3 }, /* (249) expr ::= LP expr RP */
-  {  278,   -1 }, /* (250) expr ::= ID */
-  {  278,   -3 }, /* (251) expr ::= ID DOT ID */
-  {  278,   -3 }, /* (252) expr ::= ID DOT STAR */
-  {  278,   -1 }, /* (253) expr ::= INTEGER */
-  {  278,   -2 }, /* (254) expr ::= MINUS INTEGER */
-  {  278,   -2 }, /* (255) expr ::= PLUS INTEGER */
-  {  278,   -1 }, /* (256) expr ::= FLOAT */
-  {  278,   -2 }, /* (257) expr ::= MINUS FLOAT */
-  {  278,   -2 }, /* (258) expr ::= PLUS FLOAT */
-  {  278,   -1 }, /* (259) expr ::= STRING */
-  {  278,   -1 }, /* (260) expr ::= NOW */
-  {  278,   -1 }, /* (261) expr ::= TODAY */
-  {  278,   -1 }, /* (262) expr ::= VARIABLE */
-  {  278,   -2 }, /* (263) expr ::= PLUS VARIABLE */
-  {  278,   -2 }, /* (264) expr ::= MINUS VARIABLE */
-  {  278,   -1 }, /* (265) expr ::= BOOL */
-  {  278,   -1 }, /* (266) expr ::= NULL */
-  {  278,   -4 }, /* (267) expr ::= ID LP exprlist RP */
-  {  278,   -4 }, /* (268) expr ::= ID LP STAR RP */
-  {  278,   -6 }, /* (269) expr ::= ID LP expr AS typename RP */
-  {  278,   -3 }, /* (270) expr ::= expr IS NULL */
-  {  278,   -4 }, /* (271) expr ::= expr IS NOT NULL */
-  {  278,   -3 }, /* (272) expr ::= expr LT expr */
-  {  278,   -3 }, /* (273) expr ::= expr GT expr */
-  {  278,   -3 }, /* (274) expr ::= expr LE expr */
-  {  278,   -3 }, /* (275) expr ::= expr GE expr */
-  {  278,   -3 }, /* (276) expr ::= expr NE expr */
-  {  278,   -3 }, /* (277) expr ::= expr EQ expr */
-  {  278,   -5 }, /* (278) expr ::= expr BETWEEN expr AND expr */
-  {  278,   -3 }, /* (279) expr ::= expr AND expr */
-  {  278,   -3 }, /* (280) expr ::= expr OR expr */
-  {  278,   -3 }, /* (281) expr ::= expr PLUS expr */
-  {  278,   -3 }, /* (282) expr ::= expr MINUS expr */
-  {  278,   -3 }, /* (283) expr ::= expr STAR expr */
-  {  278,   -3 }, /* (284) expr ::= expr SLASH expr */
-  {  278,   -3 }, /* (285) expr ::= expr REM expr */
-  {  278,   -3 }, /* (286) expr ::= expr BITAND expr */
-  {  278,   -3 }, /* (287) expr ::= expr LIKE expr */
-  {  278,   -3 }, /* (288) expr ::= expr MATCH expr */
-  {  278,   -3 }, /* (289) expr ::= expr NMATCH expr */
-  {  278,   -3 }, /* (290) expr ::= ID CONTAINS STRING */
-  {  278,   -5 }, /* (291) expr ::= ID DOT ID CONTAINS STRING */
-  {  288,   -3 }, /* (292) arrow ::= ID ARROW STRING */
-  {  288,   -5 }, /* (293) arrow ::= ID DOT ID ARROW STRING */
-  {  278,   -1 }, /* (294) expr ::= arrow */
-  {  278,   -5 }, /* (295) expr ::= expr IN LP exprlist RP */
-  {  214,   -3 }, /* (296) exprlist ::= exprlist COMMA expritem */
-  {  214,   -1 }, /* (297) exprlist ::= expritem */
-  {  290,   -1 }, /* (298) expritem ::= expr */
-  {  290,    0 }, /* (299) expritem ::= */
-  {  206,   -3 }, /* (300) cmd ::= RESET QUERY CACHE */
-  {  206,   -3 }, /* (301) cmd ::= SYNCDB ids REPLICA */
-  {  206,   -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  206,   -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  206,   -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-  {  206,   -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  206,   -7 }, /* (306) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  206,   -8 }, /* (307) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  206,   -9 }, /* (308) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  206,   -7 }, /* (309) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-  {  206,   -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  206,   -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  206,   -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-  {  206,   -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  206,   -7 }, /* (314) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  206,   -8 }, /* (315) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  206,   -9 }, /* (316) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-  {  206,   -7 }, /* (317) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-  {  206,   -3 }, /* (318) cmd ::= KILL CONNECTION INTEGER */
-  {  206,   -5 }, /* (319) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  206,   -5 }, /* (320) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  206,   -1 }, /* (0) program ::= cmd */
+  {  207,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  207,   -2 }, /* (2) cmd ::= SHOW TOPICS */
+  {  207,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
+  {  207,   -2 }, /* (4) cmd ::= SHOW MNODES */
+  {  207,   -2 }, /* (5) cmd ::= SHOW DNODES */
+  {  207,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
+  {  207,   -2 }, /* (7) cmd ::= SHOW USERS */
+  {  207,   -2 }, /* (8) cmd ::= SHOW MODULES */
+  {  207,   -2 }, /* (9) cmd ::= SHOW QUERIES */
+  {  207,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
+  {  207,   -2 }, /* (11) cmd ::= SHOW STREAMS */
+  {  207,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
+  {  207,   -2 }, /* (13) cmd ::= SHOW SCORES */
+  {  207,   -2 }, /* (14) cmd ::= SHOW GRANTS */
+  {  207,   -2 }, /* (15) cmd ::= SHOW VNODES */
+  {  207,   -3 }, /* (16) cmd ::= SHOW VNODES ids */
+  {  209,    0 }, /* (17) dbPrefix ::= */
+  {  209,   -2 }, /* (18) dbPrefix ::= ids DOT */
+  {  210,    0 }, /* (19) cpxName ::= */
+  {  210,   -2 }, /* (20) cpxName ::= DOT ids */
+  {  207,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  207,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
+  {  207,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
+  {  207,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
+  {  207,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
+  {  207,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
+  {  207,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
+  {  207,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
+  {  207,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  207,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
+  {  207,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
+  {  207,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
+  {  207,   -3 }, /* (33) cmd ::= DROP FUNCTION ids */
+  {  207,   -3 }, /* (34) cmd ::= DROP DNODE ids */
+  {  207,   -3 }, /* (35) cmd ::= DROP USER ids */
+  {  207,   -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
+  {  207,   -2 }, /* (37) cmd ::= USE ids */
+  {  207,   -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
+  {  207,   -3 }, /* (39) cmd ::= DESC ids cpxName */
+  {  207,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
+  {  207,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  207,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
+  {  207,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
+  {  207,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
+  {  207,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
+  {  207,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  207,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
+  {  207,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  207,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  207,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
+  {  208,   -1 }, /* (51) ids ::= ID */
+  {  208,   -1 }, /* (52) ids ::= STRING */
+  {  211,   -2 }, /* (53) ifexists ::= IF EXISTS */
+  {  211,    0 }, /* (54) ifexists ::= */
+  {  216,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
+  {  216,    0 }, /* (56) ifnotexists ::= */
+  {  207,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
+  {  207,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  207,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  207,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
+  {  207,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  207,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  207,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
+  {  220,    0 }, /* (64) bufsize ::= */
+  {  220,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
+  {  221,    0 }, /* (66) pps ::= */
+  {  221,   -2 }, /* (67) pps ::= PPS INTEGER */
+  {  222,    0 }, /* (68) tseries ::= */
+  {  222,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
+  {  223,    0 }, /* (70) dbs ::= */
+  {  223,   -2 }, /* (71) dbs ::= DBS INTEGER */
+  {  224,    0 }, /* (72) streams ::= */
+  {  224,   -2 }, /* (73) streams ::= STREAMS INTEGER */
+  {  225,    0 }, /* (74) storage ::= */
+  {  225,   -2 }, /* (75) storage ::= STORAGE INTEGER */
+  {  226,    0 }, /* (76) qtime ::= */
+  {  226,   -2 }, /* (77) qtime ::= QTIME INTEGER */
+  {  227,    0 }, /* (78) users ::= */
+  {  227,   -2 }, /* (79) users ::= USERS INTEGER */
+  {  228,    0 }, /* (80) conns ::= */
+  {  228,   -2 }, /* (81) conns ::= CONNS INTEGER */
+  {  229,    0 }, /* (82) state ::= */
+  {  229,   -2 }, /* (83) state ::= STATE ids */
+  {  214,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  230,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
+  {  230,   -1 }, /* (86) intitemlist ::= intitem */
+  {  231,   -1 }, /* (87) intitem ::= INTEGER */
+  {  232,   -2 }, /* (88) keep ::= KEEP intitemlist */
+  {  233,   -2 }, /* (89) cache ::= CACHE INTEGER */
+  {  234,   -2 }, /* (90) replica ::= REPLICA INTEGER */
+  {  235,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
+  {  236,   -2 }, /* (92) days ::= DAYS INTEGER */
+  {  237,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
+  {  238,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
+  {  239,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
+  {  240,   -2 }, /* (96) ctime ::= CTIME INTEGER */
+  {  241,   -2 }, /* (97) wal ::= WAL INTEGER */
+  {  242,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
+  {  243,   -2 }, /* (99) comp ::= COMP INTEGER */
+  {  244,   -2 }, /* (100) prec ::= PRECISION STRING */
+  {  245,   -2 }, /* (101) update ::= UPDATE INTEGER */
+  {  246,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
+  {  247,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
+  {  217,    0 }, /* (104) db_optr ::= */
+  {  217,   -2 }, /* (105) db_optr ::= db_optr cache */
+  {  217,   -2 }, /* (106) db_optr ::= db_optr replica */
+  {  217,   -2 }, /* (107) db_optr ::= db_optr quorum */
+  {  217,   -2 }, /* (108) db_optr ::= db_optr days */
+  {  217,   -2 }, /* (109) db_optr ::= db_optr minrows */
+  {  217,   -2 }, /* (110) db_optr ::= db_optr maxrows */
+  {  217,   -2 }, /* (111) db_optr ::= db_optr blocks */
+  {  217,   -2 }, /* (112) db_optr ::= db_optr ctime */
+  {  217,   -2 }, /* (113) db_optr ::= db_optr wal */
+  {  217,   -2 }, /* (114) db_optr ::= db_optr fsync */
+  {  217,   -2 }, /* (115) db_optr ::= db_optr comp */
+  {  217,   -2 }, /* (116) db_optr ::= db_optr prec */
+  {  217,   -2 }, /* (117) db_optr ::= db_optr keep */
+  {  217,   -2 }, /* (118) db_optr ::= db_optr update */
+  {  217,   -2 }, /* (119) db_optr ::= db_optr cachelast */
+  {  218,   -1 }, /* (120) topic_optr ::= db_optr */
+  {  218,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
+  {  212,    0 }, /* (122) alter_db_optr ::= */
+  {  212,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
+  {  212,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
+  {  212,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
+  {  212,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
+  {  212,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
+  {  212,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
+  {  212,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
+  {  213,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
+  {  213,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
+  {  219,   -1 }, /* (132) typename ::= ids */
+  {  219,   -4 }, /* (133) typename ::= ids LP signed RP */
+  {  219,   -2 }, /* (134) typename ::= ids UNSIGNED */
+  {  248,   -1 }, /* (135) signed ::= INTEGER */
+  {  248,   -2 }, /* (136) signed ::= PLUS INTEGER */
+  {  248,   -2 }, /* (137) signed ::= MINUS INTEGER */
+  {  207,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
+  {  207,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
+  {  207,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
+  {  207,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
+  {  251,   -1 }, /* (142) create_table_list ::= create_from_stable */
+  {  251,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
+  {  249,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  250,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  252,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  252,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+  {  255,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
+  {  255,   -1 }, /* (149) tagNamelist ::= ids */
+  {  249,   -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
+  {  256,    0 }, /* (151) to_opt ::= */
+  {  256,   -3 }, /* (152) to_opt ::= TO ids cpxName */
+  {  257,    0 }, /* (153) split_opt ::= */
+  {  257,   -2 }, /* (154) split_opt ::= SPLIT ids */
+  {  253,   -3 }, /* (155) columnlist ::= columnlist COMMA column */
+  {  253,   -1 }, /* (156) columnlist ::= column */
+  {  260,   -2 }, /* (157) column ::= ids typename */
+  {  254,   -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  254,   -1 }, /* (159) tagitemlist ::= tagitem */
+  {  261,   -1 }, /* (160) tagitem ::= INTEGER */
+  {  261,   -1 }, /* (161) tagitem ::= FLOAT */
+  {  261,   -1 }, /* (162) tagitem ::= STRING */
+  {  261,   -1 }, /* (163) tagitem ::= BOOL */
+  {  261,   -1 }, /* (164) tagitem ::= NULL */
+  {  261,   -1 }, /* (165) tagitem ::= NOW */
+  {  261,   -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */
+  {  261,   -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */
+  {  261,   -2 }, /* (168) tagitem ::= MINUS INTEGER */
+  {  261,   -2 }, /* (169) tagitem ::= MINUS FLOAT */
+  {  261,   -2 }, /* (170) tagitem ::= PLUS INTEGER */
+  {  261,   -2 }, /* (171) tagitem ::= PLUS FLOAT */
+  {  258,  -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+  {  258,   -3 }, /* (173) select ::= LP select RP */
+  {  276,   -1 }, /* (174) union ::= select */
+  {  276,   -4 }, /* (175) union ::= union UNION ALL select */
+  {  207,   -1 }, /* (176) cmd ::= union */
+  {  258,   -2 }, /* (177) select ::= SELECT selcollist */
+  {  277,   -2 }, /* (178) sclp ::= selcollist COMMA */
+  {  277,    0 }, /* (179) sclp ::= */
+  {  262,   -4 }, /* (180) selcollist ::= sclp distinct expr as */
+  {  262,   -2 }, /* (181) selcollist ::= sclp STAR */
+  {  280,   -2 }, /* (182) as ::= AS ids */
+  {  280,   -1 }, /* (183) as ::= ids */
+  {  280,    0 }, /* (184) as ::= */
+  {  278,   -1 }, /* (185) distinct ::= DISTINCT */
+  {  278,    0 }, /* (186) distinct ::= */
+  {  263,   -2 }, /* (187) from ::= FROM tablelist */
+  {  263,   -2 }, /* (188) from ::= FROM sub */
+  {  282,   -3 }, /* (189) sub ::= LP union RP */
+  {  282,   -4 }, /* (190) sub ::= LP union RP ids */
+  {  282,   -6 }, /* (191) sub ::= sub COMMA LP union RP ids */
+  {  281,   -2 }, /* (192) tablelist ::= ids cpxName */
+  {  281,   -3 }, /* (193) tablelist ::= ids cpxName ids */
+  {  281,   -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */
+  {  281,   -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  283,   -1 }, /* (196) tmvar ::= VARIABLE */
+  {  284,   -1 }, /* (197) timestamp ::= INTEGER */
+  {  284,   -2 }, /* (198) timestamp ::= MINUS INTEGER */
+  {  284,   -2 }, /* (199) timestamp ::= PLUS INTEGER */
+  {  284,   -1 }, /* (200) timestamp ::= STRING */
+  {  284,   -1 }, /* (201) timestamp ::= NOW */
+  {  284,   -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */
+  {  284,   -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */
+  {  265,    0 }, /* (204) range_option ::= */
+  {  265,   -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */
+  {  266,   -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */
+  {  266,   -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+  {  266,    0 }, /* (208) interval_option ::= */
+  {  285,   -1 }, /* (209) intervalKey ::= INTERVAL */
+  {  285,   -1 }, /* (210) intervalKey ::= EVERY */
+  {  268,    0 }, /* (211) session_option ::= */
+  {  268,   -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  269,    0 }, /* (213) windowstate_option ::= */
+  {  269,   -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */
+  {  270,    0 }, /* (215) fill_opt ::= */
+  {  270,   -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  270,   -4 }, /* (217) fill_opt ::= FILL LP ID RP */
+  {  267,   -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */
+  {  267,    0 }, /* (219) sliding_opt ::= */
+  {  273,    0 }, /* (220) orderby_opt ::= */
+  {  273,   -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */
+  {  286,   -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */
+  {  286,   -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */
+  {  286,   -2 }, /* (224) sortlist ::= item sortorder */
+  {  286,   -2 }, /* (225) sortlist ::= arrow sortorder */
+  {  287,   -1 }, /* (226) item ::= ID */
+  {  287,   -3 }, /* (227) item ::= ID DOT ID */
+  {  288,   -1 }, /* (228) sortorder ::= ASC */
+  {  288,   -1 }, /* (229) sortorder ::= DESC */
+  {  288,    0 }, /* (230) sortorder ::= */
+  {  271,    0 }, /* (231) groupby_opt ::= */
+  {  271,   -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */
+  {  290,   -3 }, /* (233) grouplist ::= grouplist COMMA item */
+  {  290,   -3 }, /* (234) grouplist ::= grouplist COMMA arrow */
+  {  290,   -1 }, /* (235) grouplist ::= item */
+  {  290,   -1 }, /* (236) grouplist ::= arrow */
+  {  272,    0 }, /* (237) having_opt ::= */
+  {  272,   -2 }, /* (238) having_opt ::= HAVING expr */
+  {  275,    0 }, /* (239) limit_opt ::= */
+  {  275,   -2 }, /* (240) limit_opt ::= LIMIT signed */
+  {  275,   -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */
+  {  275,   -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */
+  {  274,    0 }, /* (243) slimit_opt ::= */
+  {  274,   -2 }, /* (244) slimit_opt ::= SLIMIT signed */
+  {  274,   -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  274,   -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  264,    0 }, /* (247) where_opt ::= */
+  {  264,   -2 }, /* (248) where_opt ::= WHERE expr */
+  {  279,   -3 }, /* (249) expr ::= LP expr RP */
+  {  279,   -1 }, /* (250) expr ::= ID */
+  {  279,   -3 }, /* (251) expr ::= ID DOT ID */
+  {  279,   -3 }, /* (252) expr ::= ID DOT STAR */
+  {  279,   -1 }, /* (253) expr ::= INTEGER */
+  {  279,   -2 }, /* (254) expr ::= MINUS INTEGER */
+  {  279,   -2 }, /* (255) expr ::= PLUS INTEGER */
+  {  279,   -1 }, /* (256) expr ::= FLOAT */
+  {  279,   -2 }, /* (257) expr ::= MINUS FLOAT */
+  {  279,   -2 }, /* (258) expr ::= PLUS FLOAT */
+  {  279,   -1 }, /* (259) expr ::= STRING */
+  {  279,   -1 }, /* (260) expr ::= NOW */
+  {  279,   -1 }, /* (261) expr ::= TODAY */
+  {  279,   -1 }, /* (262) expr ::= VARIABLE */
+  {  279,   -2 }, /* (263) expr ::= PLUS VARIABLE */
+  {  279,   -2 }, /* (264) expr ::= MINUS VARIABLE */
+  {  279,   -1 }, /* (265) expr ::= BOOL */
+  {  279,   -1 }, /* (266) expr ::= NULL */
+  {  279,   -4 }, /* (267) expr ::= ID LP exprlist RP */
+  {  279,   -4 }, /* (268) expr ::= ID LP STAR RP */
+  {  279,   -6 }, /* (269) expr ::= ID LP expr AS typename RP */
+  {  279,   -3 }, /* (270) expr ::= expr IS NULL */
+  {  279,   -4 }, /* (271) expr ::= expr IS NOT NULL */
+  {  279,   -3 }, /* (272) expr ::= expr LT expr */
+  {  279,   -3 }, /* (273) expr ::= expr GT expr */
+  {  279,   -3 }, /* (274) expr ::= expr LE expr */
+  {  279,   -3 }, /* (275) expr ::= expr GE expr */
+  {  279,   -3 }, /* (276) expr ::= expr NE expr */
+  {  279,   -3 }, /* (277) expr ::= expr EQ expr */
+  {  279,   -5 }, /* (278) expr ::= expr BETWEEN expr AND expr */
+  {  279,   -3 }, /* (279) expr ::= expr AND expr */
+  {  279,   -3 }, /* (280) expr ::= expr OR expr */
+  {  279,   -3 }, /* (281) expr ::= expr PLUS expr */
+  {  279,   -3 }, /* (282) expr ::= expr MINUS expr */
+  {  279,   -3 }, /* (283) expr ::= expr STAR expr */
+  {  279,   -3 }, /* (284) expr ::= expr SLASH expr */
+  {  279,   -3 }, /* (285) expr ::= expr REM expr */
+  {  279,   -3 }, /* (286) expr ::= expr BITAND expr */
+  {  279,   -3 }, /* (287) expr ::= expr LIKE expr */
+  {  279,   -3 }, /* (288) expr ::= expr MATCH expr */
+  {  279,   -3 }, /* (289) expr ::= expr NMATCH expr */
+  {  279,   -3 }, /* (290) expr ::= ID CONTAINS STRING */
+  {  279,   -5 }, /* (291) expr ::= ID DOT ID CONTAINS STRING */
+  {  289,   -3 }, /* (292) arrow ::= ID ARROW STRING */
+  {  289,   -5 }, /* (293) arrow ::= ID DOT ID ARROW STRING */
+  {  279,   -1 }, /* (294) expr ::= arrow */
+  {  279,   -5 }, /* (295) expr ::= expr IN LP exprlist RP */
+  {  215,   -3 }, /* (296) exprlist ::= exprlist COMMA expritem */
+  {  215,   -1 }, /* (297) exprlist ::= expritem */
+  {  291,   -1 }, /* (298) expritem ::= expr */
+  {  291,    0 }, /* (299) expritem ::= */
+  {  207,   -3 }, /* (300) cmd ::= RESET QUERY CACHE */
+  {  207,   -3 }, /* (301) cmd ::= SYNCDB ids REPLICA */
+  {  207,   -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  207,   -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  207,   -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+  {  207,   -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  207,   -7 }, /* (306) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  207,   -8 }, /* (307) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  207,   -9 }, /* (308) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  207,   -7 }, /* (309) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+  {  207,   -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  207,   -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  207,   -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+  {  207,   -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  207,   -7 }, /* (314) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  207,   -8 }, /* (315) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  207,   -9 }, /* (316) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+  {  207,   -7 }, /* (317) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+  {  207,   -3 }, /* (318) cmd ::= KILL CONNECTION INTEGER */
+  {  207,   -5 }, /* (319) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  207,   -5 }, /* (320) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  207,   -6 }, /* (321) cmd ::= DELETE FROM ifexists ids cpxName where_opt */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2487,16 +2494,16 @@ static void yy_reduce(
         break;
       case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
       case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
-{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy436, &t);}
+{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &t);}
         break;
       case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy517);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy299);}
         break;
       case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy517);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);}
         break;
       case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
-{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy525);}
+{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy333);}
         break;
       case 51: /* ids ::= ID */
       case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
@@ -2518,17 +2525,17 @@ static void yy_reduce(
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy517);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);}
         break;
       case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
       case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy436, &yymsp[-2].minor.yy0);}
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &yymsp[-2].minor.yy0);}
         break;
       case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy115, &yymsp[0].minor.yy0, 1);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 1);}
         break;
       case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy115, &yymsp[0].minor.yy0, 2);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 2);}
         break;
       case 63: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -2559,38 +2566,38 @@ static void yy_reduce(
         break;
       case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy517.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy517.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy517.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy517.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy517.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy517.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy517.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy517.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy517.stat    = yymsp[0].minor.yy0;
+    yylhsminor.yy299.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy299.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy299.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy299.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy299.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy299.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy299.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy299.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy299.stat    = yymsp[0].minor.yy0;
 }
-  yymsp[-8].minor.yy517 = yylhsminor.yy517;
+  yymsp[-8].minor.yy299 = yylhsminor.yy299;
         break;
       case 85: /* intitemlist ::= intitemlist COMMA intitem */
       case 158: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==158);
-{ yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy110, -1);    }
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+{ yylhsminor.yy333 = tVariantListAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, -1);    }
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 86: /* intitemlist ::= intitem */
       case 159: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==159);
-{ yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy110, -1); }
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+{ yylhsminor.yy333 = tVariantListAppend(NULL, &yymsp[0].minor.yy42, -1); }
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 87: /* intitem ::= INTEGER */
       case 160: /* tagitem ::= INTEGER */ yytestcase(yyruleno==160);
       case 161: /* tagitem ::= FLOAT */ yytestcase(yyruleno==161);
       case 162: /* tagitem ::= STRING */ yytestcase(yyruleno==162);
       case 163: /* tagitem ::= BOOL */ yytestcase(yyruleno==163);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy110 = yylhsminor.yy110;
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy42 = yylhsminor.yy42;
         break;
       case 88: /* keep ::= KEEP intitemlist */
-{ yymsp[-1].minor.yy525 = yymsp[0].minor.yy525; }
+{ yymsp[-1].minor.yy333 = yymsp[0].minor.yy333; }
         break;
       case 89: /* cache ::= CACHE INTEGER */
       case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
@@ -2610,200 +2617,200 @@ static void yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
       case 104: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy436); yymsp[1].minor.yy436.dbType = TSDB_DB_TYPE_DEFAULT;}
+{setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 105: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 106: /* db_optr ::= db_optr replica */
       case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 107: /* db_optr ::= db_optr quorum */
       case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 108: /* db_optr ::= db_optr days */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 109: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 110: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 111: /* db_optr ::= db_optr blocks */
       case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 112: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 113: /* db_optr ::= db_optr wal */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 114: /* db_optr ::= db_optr fsync */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 115: /* db_optr ::= db_optr comp */
       case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 116: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 117: /* db_optr ::= db_optr keep */
       case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.keep = yymsp[0].minor.yy525; }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.keep = yymsp[0].minor.yy333; }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 118: /* db_optr ::= db_optr update */
       case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 119: /* db_optr ::= db_optr cachelast */
       case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 120: /* topic_optr ::= db_optr */
       case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
-{ yylhsminor.yy436 = yymsp[0].minor.yy436; yylhsminor.yy436.dbType = TSDB_DB_TYPE_TOPIC; }
-  yymsp[0].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[0].minor.yy342; yylhsminor.yy342.dbType = TSDB_DB_TYPE_TOPIC; }
+  yymsp[0].minor.yy342 = yylhsminor.yy342;
         break;
       case 121: /* topic_optr ::= topic_optr partitions */
       case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
-{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy436 = yylhsminor.yy436;
+{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy342 = yylhsminor.yy342;
         break;
       case 122: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy436); yymsp[1].minor.yy436.dbType = TSDB_DB_TYPE_DEFAULT;}
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 132: /* typename ::= ids */
 {
   yymsp[0].minor.yy0.type = 0;
-  tSetColumnType (&yylhsminor.yy115, &yymsp[0].minor.yy0);
+  tSetColumnType (&yylhsminor.yy263, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy115 = yylhsminor.yy115;
+  yymsp[0].minor.yy263 = yylhsminor.yy263;
         break;
       case 133: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy543 <= 0) {
+  if (yymsp[-1].minor.yy277 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSetColumnType(&yylhsminor.yy115, &yymsp[-3].minor.yy0);
+    tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy543;  // negative value of name length
-    tSetColumnType(&yylhsminor.yy115, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy277;  // negative value of name length
+    tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy115 = yylhsminor.yy115;
+  yymsp[-3].minor.yy263 = yylhsminor.yy263;
         break;
       case 134: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSetColumnType (&yylhsminor.yy115, &yymsp[-1].minor.yy0);
+  tSetColumnType (&yylhsminor.yy263, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy115 = yylhsminor.yy115;
+  yymsp[-1].minor.yy263 = yylhsminor.yy263;
         break;
       case 135: /* signed ::= INTEGER */
-{ yylhsminor.yy543 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy543 = yylhsminor.yy543;
+{ yylhsminor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy277 = yylhsminor.yy277;
         break;
       case 136: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy543 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 137: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy543 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+{ yymsp[-1].minor.yy277 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
       case 141: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy572;}
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy78;}
         break;
       case 142: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy480);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy400);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy572 = pCreateTable;
+  yylhsminor.yy78 = pCreateTable;
 }
-  yymsp[0].minor.yy572 = yylhsminor.yy572;
+  yymsp[0].minor.yy78 = yylhsminor.yy78;
         break;
       case 143: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy572->childTableInfo, &yymsp[0].minor.yy480);
-  yylhsminor.yy572 = yymsp[-1].minor.yy572;
+  taosArrayPush(yymsp[-1].minor.yy78->childTableInfo, &yymsp[0].minor.yy400);
+  yylhsminor.yy78 = yymsp[-1].minor.yy78;
 }
-  yymsp[-1].minor.yy572 = yylhsminor.yy572;
+  yymsp[-1].minor.yy78 = yylhsminor.yy78;
         break;
       case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy572 = tSetCreateTableInfo(yymsp[-1].minor.yy525, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-1].minor.yy333, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy572 = yylhsminor.yy572;
+  yymsp[-5].minor.yy78 = yylhsminor.yy78;
         break;
       case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy572 = tSetCreateTableInfo(yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy572 = yylhsminor.yy572;
+  yymsp[-9].minor.yy78 = yylhsminor.yy78;
         break;
       case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy480 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy525, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy333, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy480 = yylhsminor.yy480;
+  yymsp[-9].minor.yy400 = yylhsminor.yy400;
         break;
       case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
-  yylhsminor.yy480 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+  yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
 }
-  yymsp[-12].minor.yy480 = yylhsminor.yy480;
+  yymsp[-12].minor.yy400 = yylhsminor.yy400;
         break;
       case 148: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy0); yylhsminor.yy525 = yymsp[-2].minor.yy525;  }
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+{taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy0); yylhsminor.yy333 = yymsp[-2].minor.yy333;  }
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 149: /* tagNamelist ::= ids */
-{yylhsminor.yy525 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy0);}
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+{yylhsminor.yy333 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 150: /* create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
 {
-  yylhsminor.yy572 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy86, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy78 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy144, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
 
   setCreatedStreamOpt(pInfo, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0);
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-5].minor.yy0, &yymsp[-6].minor.yy0);
 }
-  yymsp[-6].minor.yy572 = yylhsminor.yy572;
+  yymsp[-6].minor.yy78 = yylhsminor.yy78;
         break;
       case 151: /* to_opt ::= */
       case 153: /* split_opt ::= */ yytestcase(yyruleno==153);
@@ -2819,37 +2826,37 @@ static void yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
         break;
       case 155: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy115); yylhsminor.yy525 = yymsp[-2].minor.yy525;  }
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+{taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy263); yylhsminor.yy333 = yymsp[-2].minor.yy333;  }
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 156: /* columnlist ::= column */
-{yylhsminor.yy525 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy115);}
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+{yylhsminor.yy333 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy263);}
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 157: /* column ::= ids typename */
 {
-  tSetColumnInfo(&yylhsminor.yy115, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy115);
+  tSetColumnInfo(&yylhsminor.yy263, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy263);
 }
-  yymsp[-1].minor.yy115 = yylhsminor.yy115;
+  yymsp[-1].minor.yy263 = yylhsminor.yy263;
         break;
       case 164: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy110 = yylhsminor.yy110;
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy42 = yylhsminor.yy42;
         break;
       case 165: /* tagitem ::= NOW */
-{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy110, &yymsp[0].minor.yy0, TK_NOW, true);}
-  yymsp[0].minor.yy110 = yylhsminor.yy110;
+{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy42, &yymsp[0].minor.yy0, TK_NOW, true);}
+  yymsp[0].minor.yy42 = yylhsminor.yy42;
         break;
       case 166: /* tagitem ::= NOW PLUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy110, &yymsp[0].minor.yy0, TK_PLUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_PLUS, true);
 }
         break;
       case 167: /* tagitem ::= NOW MINUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy110, &yymsp[0].minor.yy0, TK_MINUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_MINUS, true);
 }
         break;
       case 168: /* tagitem ::= MINUS INTEGER */
@@ -2860,56 +2867,56 @@ static void yy_reduce(
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy110, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy42, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy110 = yylhsminor.yy110;
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 172: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy525, yymsp[-12].minor.yy328, yymsp[-11].minor.yy142, yymsp[-4].minor.yy525, yymsp[-2].minor.yy525, &yymsp[-9].minor.yy238, &yymsp[-7].minor.yy319, &yymsp[-6].minor.yy546, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, &yymsp[0].minor.yy6, &yymsp[-1].minor.yy6, yymsp[-3].minor.yy142, &yymsp[-10].minor.yy330);
+  yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy333, yymsp[-12].minor.yy516, yymsp[-11].minor.yy194, yymsp[-4].minor.yy333, yymsp[-2].minor.yy333, &yymsp[-9].minor.yy200, &yymsp[-7].minor.yy235, &yymsp[-6].minor.yy248, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, &yymsp[0].minor.yy190, &yymsp[-1].minor.yy190, yymsp[-3].minor.yy194, &yymsp[-10].minor.yy132);
 }
-  yymsp[-14].minor.yy86 = yylhsminor.yy86;
+  yymsp[-14].minor.yy144 = yylhsminor.yy144;
         break;
       case 173: /* select ::= LP select RP */
-{yymsp[-2].minor.yy86 = yymsp[-1].minor.yy86;}
+{yymsp[-2].minor.yy144 = yymsp[-1].minor.yy144;}
         break;
       case 174: /* union ::= select */
-{ yylhsminor.yy525 = setSubclause(NULL, yymsp[0].minor.yy86); }
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+{ yylhsminor.yy333 = setSubclause(NULL, yymsp[0].minor.yy144); }
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 175: /* union ::= union UNION ALL select */
-{ yylhsminor.yy525 = appendSelectClause(yymsp[-3].minor.yy525, yymsp[0].minor.yy86); }
-  yymsp[-3].minor.yy525 = yylhsminor.yy525;
+{ yylhsminor.yy333 = appendSelectClause(yymsp[-3].minor.yy333, yymsp[0].minor.yy144); }
+  yymsp[-3].minor.yy333 = yylhsminor.yy333;
         break;
       case 176: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy525, NULL, TSDB_SQL_SELECT); }
+{ setSqlInfo(pInfo, yymsp[0].minor.yy333, NULL, TSDB_SQL_SELECT); }
         break;
       case 177: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy525, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy333, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy86 = yylhsminor.yy86;
+  yymsp[-1].minor.yy144 = yylhsminor.yy144;
         break;
       case 178: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy525 = yymsp[-1].minor.yy525;}
-  yymsp[-1].minor.yy525 = yylhsminor.yy525;
+{yylhsminor.yy333 = yymsp[-1].minor.yy333;}
+  yymsp[-1].minor.yy333 = yylhsminor.yy333;
         break;
       case 179: /* sclp ::= */
       case 220: /* orderby_opt ::= */ yytestcase(yyruleno==220);
-{yymsp[1].minor.yy525 = 0;}
+{yymsp[1].minor.yy333 = 0;}
         break;
       case 180: /* selcollist ::= sclp distinct expr as */
 {
-   yylhsminor.yy525 = tSqlExprListAppend(yymsp[-3].minor.yy525, yymsp[-1].minor.yy142,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy333 = tSqlExprListAppend(yymsp[-3].minor.yy333, yymsp[-1].minor.yy194,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-3].minor.yy525 = yylhsminor.yy525;
+  yymsp[-3].minor.yy333 = yylhsminor.yy333;
         break;
       case 181: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(pInfo, NULL, TK_ALL);
-   yylhsminor.yy525 = tSqlExprListAppend(yymsp[-1].minor.yy525, pNode, 0, 0);
+   yylhsminor.yy333 = tSqlExprListAppend(yymsp[-1].minor.yy333, pNode, 0, 0);
 }
-  yymsp[-1].minor.yy525 = yylhsminor.yy525;
+  yymsp[-1].minor.yy333 = yylhsminor.yy333;
         break;
       case 182: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
@@ -2927,114 +2934,114 @@ static void yy_reduce(
         break;
       case 187: /* from ::= FROM tablelist */
       case 188: /* from ::= FROM sub */ yytestcase(yyruleno==188);
-{yymsp[-1].minor.yy328 = yymsp[0].minor.yy328;}
+{yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;}
         break;
       case 189: /* sub ::= LP union RP */
-{yymsp[-2].minor.yy328 = addSubqueryElem(NULL, yymsp[-1].minor.yy525, NULL);}
+{yymsp[-2].minor.yy516 = addSubqueryElem(NULL, yymsp[-1].minor.yy333, NULL);}
         break;
       case 190: /* sub ::= LP union RP ids */
-{yymsp[-3].minor.yy328 = addSubqueryElem(NULL, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
+{yymsp[-3].minor.yy516 = addSubqueryElem(NULL, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);}
         break;
       case 191: /* sub ::= sub COMMA LP union RP ids */
-{yylhsminor.yy328 = addSubqueryElem(yymsp[-5].minor.yy328, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
-  yymsp[-5].minor.yy328 = yylhsminor.yy328;
+{yylhsminor.yy516 = addSubqueryElem(yymsp[-5].minor.yy516, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);}
+  yymsp[-5].minor.yy516 = yylhsminor.yy516;
         break;
       case 192: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy328 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy328 = yylhsminor.yy328;
+  yymsp[-1].minor.yy516 = yylhsminor.yy516;
         break;
       case 193: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy328 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy328 = yylhsminor.yy328;
+  yymsp[-2].minor.yy516 = yylhsminor.yy516;
         break;
       case 194: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy328 = setTableNameList(yymsp[-3].minor.yy328, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy516 = setTableNameList(yymsp[-3].minor.yy516, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy328 = yylhsminor.yy328;
+  yymsp[-3].minor.yy516 = yylhsminor.yy516;
         break;
       case 195: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy328 = setTableNameList(yymsp[-4].minor.yy328, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy516 = setTableNameList(yymsp[-4].minor.yy516, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy328 = yylhsminor.yy328;
+  yymsp[-4].minor.yy516 = yylhsminor.yy516;
         break;
       case 196: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 197: /* timestamp ::= INTEGER */
-{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 198: /* timestamp ::= MINUS INTEGER */
       case 199: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==199);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy194 = yylhsminor.yy194;
         break;
       case 200: /* timestamp ::= STRING */
-{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 201: /* timestamp ::= NOW */
-{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 202: /* timestamp ::= NOW PLUS VARIABLE */
-{yymsp[-2].minor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
+{yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
         break;
       case 203: /* timestamp ::= NOW MINUS VARIABLE */
-{yymsp[-2].minor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
+{yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
         break;
       case 204: /* range_option ::= */
-{yymsp[1].minor.yy330.start = 0; yymsp[1].minor.yy330.end = 0;}
+{yymsp[1].minor.yy132.start = 0; yymsp[1].minor.yy132.end = 0;}
         break;
       case 205: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */
-{yymsp[-5].minor.yy330.start = yymsp[-3].minor.yy142; yymsp[-5].minor.yy330.end = yymsp[-1].minor.yy142;}
+{yymsp[-5].minor.yy132.start = yymsp[-3].minor.yy194; yymsp[-5].minor.yy132.end = yymsp[-1].minor.yy194;}
         break;
       case 206: /* interval_option ::= intervalKey LP tmvar RP */
-{yylhsminor.yy238.interval = yymsp[-1].minor.yy0; yylhsminor.yy238.offset.n = 0; yylhsminor.yy238.token = yymsp[-3].minor.yy508;}
-  yymsp[-3].minor.yy238 = yylhsminor.yy238;
+{yylhsminor.yy200.interval = yymsp[-1].minor.yy0; yylhsminor.yy200.offset.n = 0; yylhsminor.yy200.token = yymsp[-3].minor.yy44;}
+  yymsp[-3].minor.yy200 = yylhsminor.yy200;
         break;
       case 207: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-{yylhsminor.yy238.interval = yymsp[-3].minor.yy0; yylhsminor.yy238.offset = yymsp[-1].minor.yy0;   yylhsminor.yy238.token = yymsp[-5].minor.yy508;}
-  yymsp[-5].minor.yy238 = yylhsminor.yy238;
+{yylhsminor.yy200.interval = yymsp[-3].minor.yy0; yylhsminor.yy200.offset = yymsp[-1].minor.yy0;   yylhsminor.yy200.token = yymsp[-5].minor.yy44;}
+  yymsp[-5].minor.yy200 = yylhsminor.yy200;
         break;
       case 208: /* interval_option ::= */
-{memset(&yymsp[1].minor.yy238, 0, sizeof(yymsp[1].minor.yy238));}
+{memset(&yymsp[1].minor.yy200, 0, sizeof(yymsp[1].minor.yy200));}
         break;
       case 209: /* intervalKey ::= INTERVAL */
-{yymsp[0].minor.yy508 = TK_INTERVAL;}
+{yymsp[0].minor.yy44 = TK_INTERVAL;}
         break;
       case 210: /* intervalKey ::= EVERY */
-{yymsp[0].minor.yy508 = TK_EVERY;   }
+{yymsp[0].minor.yy44 = TK_EVERY;   }
         break;
       case 211: /* session_option ::= */
-{yymsp[1].minor.yy319.col.n = 0; yymsp[1].minor.yy319.gap.n = 0;}
+{yymsp[1].minor.yy235.col.n = 0; yymsp[1].minor.yy235.gap.n = 0;}
         break;
       case 212: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-   yymsp[-6].minor.yy319.col = yymsp[-4].minor.yy0;
-   yymsp[-6].minor.yy319.gap = yymsp[-1].minor.yy0;
+   yymsp[-6].minor.yy235.col = yymsp[-4].minor.yy0;
+   yymsp[-6].minor.yy235.gap = yymsp[-1].minor.yy0;
 }
         break;
       case 213: /* windowstate_option ::= */
-{ yymsp[1].minor.yy546.col.n = 0; yymsp[1].minor.yy546.col.z = NULL;}
+{ yymsp[1].minor.yy248.col.n = 0; yymsp[1].minor.yy248.col.z = NULL;}
         break;
       case 214: /* windowstate_option ::= STATE_WINDOW LP ids RP */
-{ yymsp[-3].minor.yy546.col = yymsp[-1].minor.yy0; }
+{ yymsp[-3].minor.yy248.col = yymsp[-1].minor.yy0; }
         break;
       case 215: /* fill_opt ::= */
-{ yymsp[1].minor.yy525 = 0;     }
+{ yymsp[1].minor.yy333 = 0;     }
         break;
       case 216: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
@@ -3042,14 +3049,14 @@ static void yy_reduce(
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy525, &A, -1, 0);
-    yymsp[-5].minor.yy525 = yymsp[-1].minor.yy525;
+    tVariantListInsert(yymsp[-1].minor.yy333, &A, -1, 0);
+    yymsp[-5].minor.yy333 = yymsp[-1].minor.yy333;
 }
         break;
       case 217: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy525 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
+    yymsp[-3].minor.yy333 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
 }
         break;
       case 218: /* sliding_opt ::= SLIDING LP tmvar RP */
@@ -3059,302 +3066,302 @@ static void yy_reduce(
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
       case 221: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
+{yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;}
         break;
       case 222: /* sortlist ::= sortlist COMMA item sortorder */
 {
-  yylhsminor.yy525 = commonItemAppend(yymsp[-3].minor.yy525, &yymsp[-1].minor.yy110, NULL, false, yymsp[0].minor.yy580);
+  yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133);
 }
-  yymsp[-3].minor.yy525 = yylhsminor.yy525;
+  yymsp[-3].minor.yy333 = yylhsminor.yy333;
         break;
       case 223: /* sortlist ::= sortlist COMMA arrow sortorder */
 {
-  yylhsminor.yy525 = commonItemAppend(yymsp[-3].minor.yy525, NULL, yymsp[-1].minor.yy142, true, yymsp[0].minor.yy580);
+  yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133);
 }
-  yymsp[-3].minor.yy525 = yylhsminor.yy525;
+  yymsp[-3].minor.yy333 = yylhsminor.yy333;
         break;
       case 224: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy525 = commonItemAppend(NULL, &yymsp[-1].minor.yy110, NULL, false, yymsp[0].minor.yy580);
+  yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133);
 }
-  yymsp[-1].minor.yy525 = yylhsminor.yy525;
+  yymsp[-1].minor.yy333 = yylhsminor.yy333;
         break;
       case 225: /* sortlist ::= arrow sortorder */
 {
-  yylhsminor.yy525 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy142, true, yymsp[0].minor.yy580);
+  yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133);
 }
-  yymsp[-1].minor.yy525 = yylhsminor.yy525;
+  yymsp[-1].minor.yy333 = yylhsminor.yy333;
         break;
       case 226: /* item ::= ID */
 {
   toTSDBType(yymsp[0].minor.yy0.type);
-  tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0);
+  tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy110 = yylhsminor.yy110;
+  yymsp[0].minor.yy42 = yylhsminor.yy42;
         break;
       case 227: /* item ::= ID DOT ID */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n);
-  tVariantCreate(&yylhsminor.yy110, &yymsp[-2].minor.yy0);
+  tVariantCreate(&yylhsminor.yy42, &yymsp[-2].minor.yy0);
 }
-  yymsp[-2].minor.yy110 = yylhsminor.yy110;
+  yymsp[-2].minor.yy42 = yylhsminor.yy42;
         break;
       case 228: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy580 = TSDB_ORDER_ASC; }
+{ yymsp[0].minor.yy133 = TSDB_ORDER_ASC; }
         break;
       case 229: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy580 = TSDB_ORDER_DESC;}
+{ yymsp[0].minor.yy133 = TSDB_ORDER_DESC;}
         break;
       case 230: /* sortorder ::= */
-{ yymsp[1].minor.yy580 = TSDB_ORDER_ASC; }
+{ yymsp[1].minor.yy133 = TSDB_ORDER_ASC; }
         break;
       case 231: /* groupby_opt ::= */
-{ yymsp[1].minor.yy525 = 0;}
+{ yymsp[1].minor.yy333 = 0;}
         break;
       case 232: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
+{ yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;}
         break;
       case 233: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy525 = commonItemAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy110, NULL, false, -1);
+  yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, NULL, false, -1);
 }
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 234: /* grouplist ::= grouplist COMMA arrow */
 {
-  yylhsminor.yy525 = commonItemAppend(yymsp[-2].minor.yy525, NULL, yymsp[0].minor.yy142, true, -1);
+  yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, NULL, yymsp[0].minor.yy194, true, -1);
 }
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 235: /* grouplist ::= item */
 {
-  yylhsminor.yy525 = commonItemAppend(NULL, &yymsp[0].minor.yy110, NULL, false, -1);
+  yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[0].minor.yy42, NULL, false, -1);
 }
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 236: /* grouplist ::= arrow */
 {
-  yylhsminor.yy525 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy142, true, -1);
+  yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy194, true, -1);
 }
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 237: /* having_opt ::= */
       case 247: /* where_opt ::= */ yytestcase(yyruleno==247);
       case 299: /* expritem ::= */ yytestcase(yyruleno==299);
-{yymsp[1].minor.yy142 = 0;}
+{yymsp[1].minor.yy194 = 0;}
         break;
       case 238: /* having_opt ::= HAVING expr */
       case 248: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==248);
-{yymsp[-1].minor.yy142 = yymsp[0].minor.yy142;}
+{yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;}
         break;
       case 239: /* limit_opt ::= */
       case 243: /* slimit_opt ::= */ yytestcase(yyruleno==243);
-{yymsp[1].minor.yy6.limit = -1; yymsp[1].minor.yy6.offset = 0;}
+{yymsp[1].minor.yy190.limit = -1; yymsp[1].minor.yy190.offset = 0;}
         break;
       case 240: /* limit_opt ::= LIMIT signed */
       case 244: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==244);
-{yymsp[-1].minor.yy6.limit = yymsp[0].minor.yy543;  yymsp[-1].minor.yy6.offset = 0;}
+{yymsp[-1].minor.yy190.limit = yymsp[0].minor.yy277;  yymsp[-1].minor.yy190.offset = 0;}
         break;
       case 241: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy6.limit = yymsp[-2].minor.yy543;  yymsp[-3].minor.yy6.offset = yymsp[0].minor.yy543;}
+{ yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277;  yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;}
         break;
       case 242: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy6.limit = yymsp[0].minor.yy543;  yymsp[-3].minor.yy6.offset = yymsp[-2].minor.yy543;}
+{ yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277;  yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;}
         break;
       case 245: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy6.limit = yymsp[-2].minor.yy543;  yymsp[-3].minor.yy6.offset = yymsp[0].minor.yy543;}
+{yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277;  yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;}
         break;
       case 246: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy6.limit = yymsp[0].minor.yy543;  yymsp[-3].minor.yy6.offset = yymsp[-2].minor.yy543;}
+{yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277;  yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;}
         break;
       case 249: /* expr ::= LP expr RP */
-{yylhsminor.yy142 = yymsp[-1].minor.yy142; yylhsminor.yy142->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy142->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = yymsp[-1].minor.yy194; yylhsminor.yy194->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy194->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 250: /* expr ::= ID */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 251: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 252: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 253: /* expr ::= INTEGER */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 254: /* expr ::= MINUS INTEGER */
       case 255: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==255);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy194 = yylhsminor.yy194;
         break;
       case 256: /* expr ::= FLOAT */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 257: /* expr ::= MINUS FLOAT */
       case 258: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==258);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy194 = yylhsminor.yy194;
         break;
       case 259: /* expr ::= STRING */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 260: /* expr ::= NOW */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 261: /* expr ::= TODAY */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_TODAY); }
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_TODAY); }
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 262: /* expr ::= VARIABLE */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 263: /* expr ::= PLUS VARIABLE */
       case 264: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==264);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
-  yymsp[-1].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
+  yymsp[-1].minor.yy194 = yylhsminor.yy194;
         break;
       case 265: /* expr ::= BOOL */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 266: /* expr ::= NULL */
-{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 267: /* expr ::= ID LP exprlist RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFunction(yymsp[-1].minor.yy525, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy142 = yylhsminor.yy142;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(yymsp[-1].minor.yy333, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy194 = yylhsminor.yy194;
         break;
       case 268: /* expr ::= ID LP STAR RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy142 = yylhsminor.yy142;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy194 = yylhsminor.yy194;
         break;
       case 269: /* expr ::= ID LP expr AS typename RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy142, &yymsp[-1].minor.yy115, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
-  yymsp[-5].minor.yy142 = yylhsminor.yy142;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy194, &yymsp[-1].minor.yy263, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
+  yymsp[-5].minor.yy194 = yylhsminor.yy194;
         break;
       case 270: /* expr ::= expr IS NULL */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 271: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-3].minor.yy142, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-3].minor.yy194, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy194 = yylhsminor.yy194;
         break;
       case 272: /* expr ::= expr LT expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LT);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LT);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 273: /* expr ::= expr GT expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_GT);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GT);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 274: /* expr ::= expr LE expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LE);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LE);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 275: /* expr ::= expr GE expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_GE);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GE);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 276: /* expr ::= expr NE expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_NE);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NE);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 277: /* expr ::= expr EQ expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_EQ);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_EQ);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 278: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy142); yylhsminor.yy142 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy142, yymsp[-2].minor.yy142, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy142, TK_LE), TK_AND);}
-  yymsp[-4].minor.yy142 = yylhsminor.yy142;
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy194); yylhsminor.yy194 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy194, yymsp[-2].minor.yy194, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy194, TK_LE), TK_AND);}
+  yymsp[-4].minor.yy194 = yylhsminor.yy194;
         break;
       case 279: /* expr ::= expr AND expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_AND);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_AND);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 280: /* expr ::= expr OR expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_OR); }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_OR); }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 281: /* expr ::= expr PLUS expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_PLUS);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_PLUS);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 282: /* expr ::= expr MINUS expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_MINUS); }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MINUS); }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 283: /* expr ::= expr STAR expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_STAR);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_STAR);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 284: /* expr ::= expr SLASH expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_DIVIDE);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_DIVIDE);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 285: /* expr ::= expr REM expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_REM);   }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_REM);   }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 286: /* expr ::= expr BITAND expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_BITAND);}
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_BITAND);}
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 287: /* expr ::= expr LIKE expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LIKE);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LIKE);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 288: /* expr ::= expr MATCH expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_MATCH);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MATCH);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 289: /* expr ::= expr NMATCH expr */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_NMATCH);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NMATCH);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 290: /* expr ::= ID CONTAINS STRING */
-{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 291: /* expr ::= ID DOT ID CONTAINS STRING */
-{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-4].minor.yy142 = yylhsminor.yy142;
+{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-4].minor.yy194 = yylhsminor.yy194;
         break;
       case 292: /* arrow ::= ID ARROW STRING */
-{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-2].minor.yy142 = yylhsminor.yy142;
+{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-2].minor.yy194 = yylhsminor.yy194;
         break;
       case 293: /* arrow ::= ID DOT ID ARROW STRING */
-{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-4].minor.yy142 = yylhsminor.yy142;
+{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-4].minor.yy194 = yylhsminor.yy194;
         break;
       case 294: /* expr ::= arrow */
       case 298: /* expritem ::= expr */ yytestcase(yyruleno==298);
-{yylhsminor.yy142 = yymsp[0].minor.yy142;}
-  yymsp[0].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = yymsp[0].minor.yy194;}
+  yymsp[0].minor.yy194 = yylhsminor.yy194;
         break;
       case 295: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy142 = tSqlExprCreate(yymsp[-4].minor.yy142, (tSqlExpr*)yymsp[-1].minor.yy525, TK_IN); }
-  yymsp[-4].minor.yy142 = yylhsminor.yy142;
+{yylhsminor.yy194 = tSqlExprCreate(yymsp[-4].minor.yy194, (tSqlExpr*)yymsp[-1].minor.yy333, TK_IN); }
+  yymsp[-4].minor.yy194 = yylhsminor.yy194;
         break;
       case 296: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy525 = tSqlExprListAppend(yymsp[-2].minor.yy525,yymsp[0].minor.yy142,0, 0);}
-  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+{yylhsminor.yy333 = tSqlExprListAppend(yymsp[-2].minor.yy333,yymsp[0].minor.yy194,0, 0);}
+  yymsp[-2].minor.yy333 = yylhsminor.yy333;
         break;
       case 297: /* exprlist ::= expritem */
-{yylhsminor.yy525 = tSqlExprListAppend(0,yymsp[0].minor.yy142,0, 0);}
-  yymsp[0].minor.yy525 = yylhsminor.yy525;
+{yylhsminor.yy333 = tSqlExprListAppend(0,yymsp[0].minor.yy194,0, 0);}
+  yymsp[0].minor.yy333 = yylhsminor.yy333;
         break;
       case 300: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
@@ -3365,7 +3372,7 @@ static void yy_reduce(
       case 302: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3383,14 +3390,14 @@ static void yy_reduce(
       case 304: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
       case 305: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3425,7 +3432,7 @@ static void yy_reduce(
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy110, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
@@ -3434,14 +3441,14 @@ static void yy_reduce(
       case 309: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
       case 310: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3459,14 +3466,14 @@ static void yy_reduce(
       case 312: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
       case 313: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3501,7 +3508,7 @@ static void yy_reduce(
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy110, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
@@ -3510,7 +3517,7 @@ static void yy_reduce(
       case 317: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3523,6 +3530,13 @@ static void yy_reduce(
       case 320: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
+      case 321: /* cmd ::= DELETE FROM ifexists ids cpxName where_opt */
+{
+  yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; 
+  SDelData * pDelData = tGetDelData(&yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0, yymsp[0].minor.yy194);
+  setSqlInfo(pInfo, pDelData, NULL, TSDB_SQL_DELETE_DATA);
+}
+        break;
       default:
         break;
 /********** End reduce actions ************************************************/
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 47ee0d8e229c3b4e692f4472e7f15cbd72ceb40e..95931fcbc6f46bac1e535e4684750ab1874e8f0c 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -142,6 +142,7 @@ static int32_t tsRpcNum = 0;
 #define RPC_CONN_UDPC   1
 #define RPC_CONN_TCPS   2
 #define RPC_CONN_TCPC   3
+#define RPC_CONN_AUTO   4 // need tcp use tcp
 
 void *(*taosInitConn[])(uint32_t ip, uint16_t port, char *label, int threads, void *fp, void *shandle) = {
     taosInitUdpConnection,
@@ -405,7 +406,7 @@ void rpcSendRequest(void *shandle, const SRpcEpSet *pEpSet, SRpcMsg *pMsg, int64
   // connection type is application specific. 
   // for TDengine, all the query, show commands shall have TCP connection
   char type = pMsg->msgType;
-  if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_CM_RETRIEVE
+  if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_CM_RETRIEVE || type == TSDB_MSG_TYPE_SUBMIT
     || type == TSDB_MSG_TYPE_FETCH || type == TSDB_MSG_TYPE_CM_STABLE_VGROUP
     || type == TSDB_MSG_TYPE_CM_TABLES_META || type == TSDB_MSG_TYPE_CM_TABLE_META
     || type == TSDB_MSG_TYPE_CM_SHOW || type == TSDB_MSG_TYPE_DM_STATUS || type == TSDB_MSG_TYPE_CM_ALTER_TABLE)
diff --git a/src/tsdb/inc/tsdbCommit.h b/src/tsdb/inc/tsdbCommit.h
index 9cb8417c4512182d087bd0001640256a692d14a3..19304af74c1480950a46f7db3878e17a819421af 100644
--- a/src/tsdb/inc/tsdbCommit.h
+++ b/src/tsdb/inc/tsdbCommit.h
@@ -34,7 +34,7 @@ typedef struct {
 void  tsdbGetRtnSnap(STsdbRepo *pRepo, SRtn *pRtn);
 int   tsdbEncodeKVRecord(void **buf, SKVRecord *pRecord);
 void *tsdbDecodeKVRecord(void *buf, SKVRecord *pRecord);
-void *tsdbCommitData(STsdbRepo *pRepo);
+void *tsdbCommitData(STsdbRepo *pRepo, bool end);
 int   tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn);
 int tsdbWriteBlockInfoImpl(SDFile *pHeadf, STable *pTable, SArray *pSupA, SArray *pSubA, void **ppBuf, SBlockIdx *pIdx);
 int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf);
@@ -42,6 +42,9 @@ int   tsdbWriteBlockImpl(STsdbRepo *pRepo, STable *pTable, SDFile *pDFile, SDFil
                          SBlock *pBlock, bool isLast, bool isSuper, void **ppBuf, void **ppCBuf, void **ppExBuf);
 int   tsdbApplyRtn(STsdbRepo *pRepo);
 
+// commit control command 
+int tsdbCommitControl(STsdbRepo* pRepo, SControlDataInfo* pCtlDataInfo);
+
 static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
   if (fid >= pRtn->maxFid) {
     return 0;
@@ -54,4 +57,21 @@ static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
   }
 }
 
+static FORCE_INLINE int TSDB_KEY_FID(TSKEY key, int32_t days, int8_t precision) {
+int64_t fid;
+  if (key < 0) {
+    fid = ((key + 1) / tsTickPerDay[precision] / days - 1);
+  } else {
+    fid = ((key / tsTickPerDay[precision] / days));
+  }
+
+  // check fid over int max or min, set with int max or min
+  if (fid > INT32_MAX) {
+    fid = INT32_MAX;
+  } else if(fid < INT32_MIN){
+    fid = INT32_MIN;
+  }
+  return (int)fid;
+}
+
 #endif /* _TD_TSDB_COMMIT_H_ */
\ No newline at end of file
diff --git a/src/tsdb/inc/tsdbCommitQueue.h b/src/tsdb/inc/tsdbCommitQueue.h
index b690e3bdc25d86acf7e5b9d580470a80f3f4316f..3fd65df1a4e97052a3dde00f01952b36140ed00e 100644
--- a/src/tsdb/inc/tsdbCommitQueue.h
+++ b/src/tsdb/inc/tsdbCommitQueue.h
@@ -16,8 +16,14 @@
 #ifndef _TD_TSDB_COMMIT_QUEUE_H_
 #define _TD_TSDB_COMMIT_QUEUE_H_
 
-typedef enum { COMMIT_REQ, COMPACT_REQ,COMMIT_CONFIG_REQ } TSDB_REQ_T;
+typedef enum {
+  COMMIT_REQ,
+  COMMIT_BOTH_REQ,
+  COMPACT_REQ,
+  CONTROL_REQ,
+  COMMIT_CONFIG_REQ,
+} TSDB_REQ_T;
 
-int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req);
+int tsdbScheduleCommit(STsdbRepo *pRepo, void* param, TSDB_REQ_T req);
 
 #endif /* _TD_TSDB_COMMIT_QUEUE_H_ */
\ No newline at end of file
diff --git a/src/tsdb/inc/tsdbDelete.h b/src/tsdb/inc/tsdbDelete.h
new file mode 100644
index 0000000000000000000000000000000000000000..895e703eb0a89e93d2583b7c5ab29dfe81bdc747
--- /dev/null
+++ b/src/tsdb/inc/tsdbDelete.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _TD_TSDB_DELETE_H_
+#define _TD_TSDB_DELETE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// SControlData addition information
+#define GET_CTLINFO_SIZE(p) (sizeof(SControlDataInfo) + p->tnum * sizeof(int32_t))
+typedef struct {
+  // addition info
+  tsem_t*      pSem;
+  bool         memNull; // pRepo->mem is NULL, this is true
+  int32_t      affectedRows;
+  SShellSubmitRspMsg *pRsp;
+  
+  // base ControlData
+  STimeWindow win;      // come from SControlData.win
+  uint32_t    command;  // come from SControlData.command
+  int32_t     tnum;     // num of tids array
+  int32_t     tids[];
+} SControlDataInfo;
+
+// -------- interface ---------
+
+// delete
+int tsdbControlDelete(STsdbRepo* pRepo, SControlDataInfo* pCtlDataInfo);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TD_TSDB_DELETE_H_ */
\ No newline at end of file
diff --git a/src/tsdb/inc/tsdbMemTable.h b/src/tsdb/inc/tsdbMemTable.h
index 67e9976c704e15ae33174ff50ffdf1a289b5182a..83e1246c9b4723a66232062cdf47cbac80d30051 100644
--- a/src/tsdb/inc/tsdbMemTable.h
+++ b/src/tsdb/inc/tsdbMemTable.h
@@ -16,6 +16,7 @@
 #ifndef _TD_TSDB_MEMTABLE_H_
 #define _TD_TSDB_MEMTABLE_H_
 
+#include "tsdbDelete.h"
 typedef struct {
   int   rowsInserted;
   int   rowsUpdated;
@@ -65,11 +66,12 @@ int   tsdbUnRefMemTable(STsdbRepo* pRepo, SMemTable* pMemTable);
 int   tsdbTakeMemSnapshot(STsdbRepo* pRepo, SMemSnapshot* pSnapshot, SArray* pATable);
 void  tsdbUnTakeMemSnapShot(STsdbRepo* pRepo, SMemSnapshot* pSnapshot);
 void* tsdbAllocBytes(STsdbRepo* pRepo, int bytes);
-int   tsdbAsyncCommit(STsdbRepo* pRepo);
+// if pCtrlData is NULL, force must be true
+int   tsdbAsyncCommit(STsdbRepo* pRepo, SControlDataInfo* pCtlDataInfo);
 int   tsdbSyncCommitConfig(STsdbRepo* pRepo);
 int   tsdbLoadDataFromCache(STable* pTable, SSkipListIterator* pIter, TSKEY maxKey, int maxRowsToRead, SDataCols* pCols,
                             TKEY* filterKeys, int nFilterKeys, bool keepDup, SMergeInfo* pMergeInfo);
-void* tsdbCommitData(STsdbRepo* pRepo);
+void* tsdbCommitData(STsdbRepo* pRepo, bool end);
 
 static FORCE_INLINE SMemRow tsdbNextIterRow(SSkipListIterator* pIter) {
   if (pIter == NULL) return NULL;
diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index 9cdb8a83aa266d04d91e07d515f0acb56703f880..13c8c506394dbea3f59b6af318d2b80a1d09adf7 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -162,7 +162,7 @@ static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {
 }
 
 static FORCE_INLINE TSKEY tsdbGetTableLastKeyImpl(STable* pTable) {
-  ASSERT((pTable->lastRow == NULL) || (pTable->lastKey == memRowKey(pTable->lastRow)));
+  ASSERT((pTable->lastRow == NULL) || (pTable->lastKey == TSKEY_INITIAL_VAL) || (pTable->lastKey == memRowKey(pTable->lastRow)));
   return pTable->lastKey;
 }
 
diff --git a/src/tsdb/inc/tsdbint.h b/src/tsdb/inc/tsdbint.h
index a7f08e61ed1ac576c1ca70c0da20e14f4b3a306f..c79ac706c1f318273f0026396e1e57f91facd689 100644
--- a/src/tsdb/inc/tsdbint.h
+++ b/src/tsdb/inc/tsdbint.h
@@ -66,6 +66,8 @@ extern "C" {
 #include "tsdbCommit.h"
 // Compact
 #include "tsdbCompact.h"
+// Delete
+#include "tsdbDelete.h"
 // Commit Queue
 #include "tsdbCommitQueue.h"
 
@@ -97,6 +99,8 @@ struct STsdbRepo {
 
   SMergeBuf       mergeBuf;  //used when update=2
   int8_t          compactState;  // compact state: inCompact/noCompact/waitingCompact?
+  int8_t          deleteState;  // truncate state: inTruncate/noTruncate/waitingTruncate
+
   pthread_t*      pthread;
 };
 
@@ -112,9 +116,10 @@ STsdbMeta* tsdbGetMeta(STsdbRepo* pRepo);
 int        tsdbCheckCommit(STsdbRepo* pRepo);
 int        tsdbRestoreInfo(STsdbRepo* pRepo);
 UNUSED_FUNC int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg);
-int32_t    tsdbLoadLastCache(STsdbRepo *pRepo, STable* pTable);
+int32_t    tsdbLoadLastCache(STsdbRepo *pRepo, STable* pTable, bool force);
 void       tsdbGetRootDir(int repoid, char dirName[]);
 void       tsdbGetDataDir(int repoid, char dirName[]);
+int        tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx, bool onlyKey);
 
 static FORCE_INLINE STsdbBufBlock* tsdbGetCurrBufBlock(STsdbRepo* pRepo) {
   ASSERT(pRepo != NULL);
diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c
index 911eb5e2792bd7321d2a6ed1ed45b2d89636ce80..6b19fdf3c1ffad31efeb06497c05fa2740636c01 100644
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
@@ -17,13 +17,6 @@
 extern int32_t tsTsdbMetaCompactRatio;
 
 #define TSDB_MAX_SUBBLOCKS 8
-static FORCE_INLINE int TSDB_KEY_FID(TSKEY key, int32_t days, int8_t precision) {
-  if (key < 0) {
-    return (int)((key + 1) / tsTickPerDay[precision] / days - 1);
-  } else {
-    return (int)((key / tsTickPerDay[precision] / days));
-  }
-}
 
 typedef struct {
   SRtn         rtn;     // retention snapshot
@@ -73,7 +66,7 @@ static int  tsdbDropMetaRecord(STsdbFS *pfs, SMFile *pMFile, uint64_t uid);
 static int  tsdbCompactMetaFile(STsdbRepo *pRepo, STsdbFS *pfs, SMFile *pMFile);
 static int  tsdbCommitTSData(STsdbRepo *pRepo);
 static void tsdbStartCommit(STsdbRepo *pRepo);
-static void tsdbEndCommit(STsdbRepo *pRepo, int eno);
+static void tsdbEndCommit(STsdbRepo *pRepo, int eno, bool end);
 static int  tsdbCommitToFile(SCommitH *pCommith, SDFileSet *pSet, int fid);
 static int  tsdbCreateCommitIters(SCommitH *pCommith);
 static void tsdbDestroyCommitIters(SCommitH *pCommith);
@@ -100,14 +93,14 @@ static bool tsdbCanAddSubBlock(SCommitH *pCommith, SBlock *pBlock, SMergeInfo *p
 static void tsdbLoadAndMergeFromCache(SDataCols *pDataCols, int *iter, SCommitIter *pCommitIter, SDataCols *pTarget,
                                       TSKEY maxKey, int maxRows, int8_t update);
 
-void *tsdbCommitData(STsdbRepo *pRepo) {
+void *tsdbCommitData(STsdbRepo *pRepo, bool end) {
   if (pRepo->imem == NULL) {
     return NULL;
   }
   tsdbStartCommit(pRepo);
 
   if (tsShortcutFlag & TSDB_SHORTCUT_RB_TSDB_COMMIT) {
-    tsdbEndCommit(pRepo, terrno);
+    tsdbEndCommit(pRepo, terrno, end);
     return NULL;
   }
 
@@ -123,14 +116,14 @@ void *tsdbCommitData(STsdbRepo *pRepo) {
     goto _err;
   }
 
-  tsdbEndCommit(pRepo, TSDB_CODE_SUCCESS);
+  tsdbEndCommit(pRepo, TSDB_CODE_SUCCESS, end);
   return NULL;
 
 _err:
   ASSERT(terrno != TSDB_CODE_SUCCESS);
   pRepo->code = terrno;
 
-  tsdbEndCommit(pRepo, terrno);
+  tsdbEndCommit(pRepo, terrno, end);
   return NULL;
 }
 
@@ -255,7 +248,8 @@ int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf) {
     pBlkIdx = (SBlockIdx *)taosArrayGet(pIdxA, i);
 
     size = tsdbEncodeSBlockIdx(NULL, pBlkIdx);
-    if (tsdbMakeRoom(ppBuf, tlen + size) < 0) return -1;
+    if (tsdbMakeRoom(ppBuf, tlen + size) < 0)
+      return -1;
 
     void *ptr = POINTER_SHIFT(*ppBuf, tlen);
     tsdbEncodeSBlockIdx(&ptr, pBlkIdx);
@@ -264,7 +258,8 @@ int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf) {
   }
 
   tlen += sizeof(TSCKSUM);
-  if (tsdbMakeRoom(ppBuf, tlen) < 0) return -1;
+  if (tsdbMakeRoom(ppBuf, tlen) < 0) 
+    return -1;
   taosCalcChecksumAppend(0, (uint8_t *)(*ppBuf), tlen);
 
   if (tsdbAppendDFile(pHeadf, *ppBuf, tlen, &offset) < tlen) {
@@ -703,7 +698,7 @@ static void tsdbStartCommit(STsdbRepo *pRepo) {
   pRepo->code = TSDB_CODE_SUCCESS;
 }
 
-static void tsdbEndCommit(STsdbRepo *pRepo, int eno) {
+static void tsdbEndCommit(STsdbRepo *pRepo, int eno, bool end) {
   if (eno != TSDB_CODE_SUCCESS) {
     tsdbEndFSTxnWithError(REPO_FS(pRepo));
   } else {
@@ -712,14 +707,21 @@ static void tsdbEndCommit(STsdbRepo *pRepo, int eno) {
 
   tsdbInfo("vgId:%d commit over, %s", REPO_ID(pRepo), (eno == TSDB_CODE_SUCCESS) ? "succeed" : "failed");
 
-  if (pRepo->appH.notifyStatus) pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_OVER, eno);
+  // notify
+  if (end && pRepo->appH.notifyStatus) {
+    pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_OVER, eno);
+  }
 
   SMemTable *pIMem = pRepo->imem;
   (void)tsdbLockRepo(pRepo);
   pRepo->imem = NULL;
   (void)tsdbUnlockRepo(pRepo);
   tsdbUnRefMemTable(pRepo, pIMem);
-  tsem_post(&(pRepo->readyToCommit));
+
+  // release readyToCommit allow next commit
+  if (end) {
+    tsem_post(&(pRepo->readyToCommit));
+  }
 }
 
 #if 0
@@ -1787,3 +1789,28 @@ int tsdbApplyRtn(STsdbRepo *pRepo) {
 
   return 0;
 }
+
+// do control task
+int tsdbCommitControl(STsdbRepo* pRepo, SControlDataInfo* pCtlDataInfo) {
+  int ret = TSDB_CODE_SUCCESS;
+  
+  // do command
+  if(pCtlDataInfo->command & CMD_DELETE_DATA) {
+    // delete data
+    ret = tsdbControlDelete(pRepo, pCtlDataInfo);
+  }
+
+  // notify response thread to response result to client
+  if (pCtlDataInfo->pSem) {
+    tsem_post(pCtlDataInfo->pSem);
+  }
+
+  // deal wal
+  if (pRepo->appH.notifyStatus) 
+    pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_OVER, ret);
+
+  // release commitSep for next commit 
+  tsem_post(&pRepo->readyToCommit);
+  
+  return ret;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbCommitQueue.c b/src/tsdb/src/tsdbCommitQueue.c
index dccb85af55b8f76739f16621a0959c29fb373b4a..6ca097fbe968beef731229da14677006d0841439 100644
--- a/src/tsdb/src/tsdbCommitQueue.c
+++ b/src/tsdb/src/tsdbCommitQueue.c
@@ -28,6 +28,7 @@ typedef struct {
 typedef struct {
   TSDB_REQ_T req;
   STsdbRepo *pRepo;
+  void *     param;
 } SReq;
 
 static void *tsdbLoopCommit(void *arg);
@@ -91,7 +92,7 @@ void tsdbDestroyCommitQueue() {
   pthread_mutex_destroy(&(pQueue->lock));
 }
 
-int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req) {
+int tsdbScheduleCommit(STsdbRepo *pRepo, void *param, TSDB_REQ_T req) {
   SCommitQueue *pQueue = &tsCommitQueue;
 
   SListNode *pNode = (SListNode *)calloc(1, sizeof(SListNode) + sizeof(SReq));
@@ -102,6 +103,7 @@ int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req) {
 
   ((SReq *)pNode->data)->req = req;
   ((SReq *)pNode->data)->pRepo = pRepo;
+  ((SReq *)pNode->data)->param = param;
 
   pthread_mutex_lock(&(pQueue->lock));
 
@@ -158,6 +160,7 @@ static void *tsdbLoopCommit(void *arg) {
   SCommitQueue *pQueue = &tsCommitQueue;
   SListNode *   pNode = NULL;
   STsdbRepo *   pRepo = NULL;
+  void *        param = NULL;
   TSDB_REQ_T    req;
 
   setThreadName("tsdbCommit");
@@ -183,19 +186,27 @@ static void *tsdbLoopCommit(void *arg) {
 
     req = ((SReq *)pNode->data)->req;
     pRepo = ((SReq *)pNode->data)->pRepo;
+    param = ((SReq *)pNode->data)->param;
 
     if (req == COMMIT_REQ) {
-      tsdbCommitData(pRepo);
+      tsdbCommitData(pRepo, true);
     } else if (req == COMPACT_REQ) {
       tsdbCompactImpl(pRepo);
-    } else if (req == COMMIT_CONFIG_REQ) {        
+    } else if (req == COMMIT_BOTH_REQ) {
+      SControlDataInfo* pCtlDataInfo = (SControlDataInfo* )param;
+      if(!pCtlDataInfo->memNull) {
+        tsdbInfo(":SDEL vgId=%d  commit mem before delete data. mem=%p imem=%p \n", REPO_ID(pRepo), pRepo->mem, pRepo->imem);
+        tsdbCommitData(pRepo, false);
+      }
+      tsdbCommitControl(pRepo, param);
+    } else if (req == COMMIT_CONFIG_REQ) {
       ASSERT(pRepo->config_changed);
       tsdbApplyRepoConfig(pRepo);
       tsem_post(&(pRepo->readyToCommit));
     } else {
       ASSERT(0);
     }
-
+    tfree(param);
     listNodeFree(pNode);
   }
 
diff --git a/src/tsdb/src/tsdbCompact.c b/src/tsdb/src/tsdbCompact.c
index f25c0bd9813bd08bc8e34137f85c456f8e8b1f27..36c3da5669e2c9aa5c889ad267af06093a6b3cea 100644
--- a/src/tsdb/src/tsdbCompact.c
+++ b/src/tsdb/src/tsdbCompact.c
@@ -97,11 +97,15 @@ _err:
 static int tsdbAsyncCompact(STsdbRepo *pRepo) {
   if (pRepo->compactState != TSDB_NO_COMPACT) {
     tsdbInfo("vgId:%d not compact tsdb again ", REPO_ID(pRepo));
-    return 0; 
-  } 
-  pRepo->compactState = TSDB_WAITING_COMPACT;   
+    return 0;
+  }
+  pRepo->compactState = TSDB_WAITING_COMPACT;
   tsem_wait(&(pRepo->readyToCommit));
-  return tsdbScheduleCommit(pRepo, COMPACT_REQ);
+  int code = tsdbScheduleCommit(pRepo, NULL, COMPACT_REQ);
+  if (code != 0) {
+    tsem_post(&(pRepo->readyToCommit));
+  }
+  return code;
 }
 
 static void tsdbStartCompact(STsdbRepo *pRepo) {
diff --git a/src/tsdb/src/tsdbDelete.c b/src/tsdb/src/tsdbDelete.c
new file mode 100644
index 0000000000000000000000000000000000000000..180f577db2e87b0950a9c2ac20ce41e1a42a778b
--- /dev/null
+++ b/src/tsdb/src/tsdbDelete.c
@@ -0,0 +1,840 @@
+/*
+ * 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 "tsdbint.h"
+#include "tsdbDelete.h"
+
+enum {
+  TSDB_NO_DELETE,
+  TSDB_IN_DELETE,
+  TSDB_WAITING_DELETE,
+};
+
+enum BlockSolve {
+  BLOCK_READ = 0,
+  BLOCK_MODIFY,
+  BLOCK_DELETE
+};
+
+typedef struct {
+  STable *    pTable;
+  SBlockIdx * pBlkIdx;
+  SBlockIdx   bIndex;
+  SBlockInfo *pInfo;
+  bool        update; // need update lastrow
+} STableDeleteH;
+
+typedef struct {
+  STsdbRepo *pRepo;
+  SRtn       rtn;
+  SFSIter    fsIter;
+  SArray *   tblArray;  // STableDeleteH, table array to cache table obj and block indexes
+  SReadH     readh;
+  SDFileSet  wSet;
+  SArray *   aBlkIdx;
+  SArray *   aSupBlk;
+  SArray *   aSubBlk;
+  SDataCols *pDCols;
+  SControlDataInfo* pCtlInfo;
+  SArray *   aUpdates;
+  SArray *   aAffectTables;
+} SDeleteH;
+
+
+#define TSDB_DELETE_WSET(pdh) (&((pdh)->wSet))
+#define TSDB_DELETE_REPO(pdh) TSDB_READ_REPO(&((pdh)->readh))
+#define TSDB_DELETE_HEAD_FILE(pdh) TSDB_DFILE_IN_SET(TSDB_DELETE_WSET(pdh), TSDB_FILE_HEAD)
+#define TSDB_DELETE_DATA_FILE(pdh) TSDB_DFILE_IN_SET(TSDB_DELETE_WSET(pdh), TSDB_FILE_DATA)
+#define TSDB_DELETE_LAST_FILE(pdh) TSDB_DFILE_IN_SET(TSDB_DELETE_WSET(pdh), TSDB_FILE_LAST)
+#define TSDB_DELETE_SMAD_FILE(pdh) TSDB_DFILE_IN_SET(TSDB_DELETE_WSET(pdh), TSDB_FILE_SMAD)
+#define TSDB_DELETE_SMAL_FILE(pdh) TSDB_DFILE_IN_SET(TSDB_DELETE_WSET(pdh), TSDB_FILE_SMAL)
+#define TSDB_DELETE_BUF(pdh) TSDB_READ_BUF(&((pdh)->readh))
+#define TSDB_DELETE_COMP_BUF(pdh) TSDB_READ_COMP_BUF(&((pdh)->readh))
+#define TSDB_DELETE_EXBUF(pdh) TSDB_READ_EXBUF(&((pdh)->readh))
+
+
+static void  tsdbStartDeleteTrans(STsdbRepo *pRepo);
+static void  tsdbEndDeleteTrans(STsdbRepo *pRepo, int eno);
+static int   tsdbDeleteTSData(STsdbRepo *pRepo, SControlDataInfo* pCtlInfo, SArray* pArray, SArray* pAffectTables);
+static int   tsdbFSetDelete(SDeleteH *pdh, SDFileSet *pSet);
+static int   tsdbInitDeleteH(SDeleteH *pdh, STsdbRepo *pRepo);
+static void  tsdbDestroyDeleteH(SDeleteH *pdh);
+static int   tsdbInitDeleteTblArray(SDeleteH *pdh);
+static void  tsdbDestroyDeleteTblArray(SDeleteH *pdh);
+static int   tsdbCacheFSetIndex(SDeleteH *pdh);
+static int   tsdbFSetInit(SDeleteH *pdh, SDFileSet *pSet);
+static void  tsdbFSetEnd(SDeleteH *pdh);
+static int   tsdbFSetDeleteImpl(SDeleteH *pdh);
+static int   tsdbBlockSolve(SDeleteH *pdh, SBlock *pBlock);
+static int   tsdbWriteBlockToFile(SDeleteH *pdh, STable *pTable, SDataCols *pDCols, void **ppBuf,
+                                       void **ppCBuf, void **ppExBuf, SBlock * pBlock);
+static int   tsdbDeleteImplCommon(STsdbRepo *pRepo, SControlDataInfo* pCtlInfo);
+
+
+// delete
+int tsdbControlDelete(STsdbRepo* pRepo, SControlDataInfo* pCtlInfo) {
+  int32_t ret = tsdbDeleteImplCommon(pRepo, pCtlInfo);
+  if(pCtlInfo->pRsp) {
+    pCtlInfo->pRsp->affectedRows = htonl(pCtlInfo->pRsp->affectedRows);
+    pCtlInfo->pRsp->numOfTables  = htonl(pCtlInfo->pRsp->numOfTables);
+    pCtlInfo->pRsp->code = ret;
+  }
+
+  return ret;
+}
+
+static void tsdbUpdateLastRow(STsdbRepo* pRepo, SArray * pArray) {
+  size_t cnt = taosArrayGetSize(pArray);
+  for (size_t i = 0; i < cnt; ++i) {
+    STable* pTable = taosArrayGetP(pArray, i);
+    tsdbLoadLastCache(pRepo, pTable, true);
+  }
+}
+
+static void tsdbClearUpdates(SArray * pArray) {
+  size_t cnt = taosArrayGetSize(pArray);
+  for (size_t i = 0; i < cnt; ++i) {
+    STable* pTable = taosArrayGetP(pArray, i);
+    tsdbUnRefTable(pTable);
+  }
+  // destory
+  taosArrayDestroy(&pArray);
+}
+
+// init new meta file with current meta file
+static int tsdbInitNewMFile(STsdbRepo *pRepo) {
+  STsdbFS *pfs = REPO_FS(pRepo);
+  tsdbUpdateMFile(pfs, pfs->cstatus->pmf);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int tsdbDeleteImplCommon(STsdbRepo *pRepo, SControlDataInfo* pCtlInfo) {
+  // check valid
+  if ((REPO_FS(pRepo)->cstatus->pmf == NULL) || (taosArrayGetSize(REPO_FS(pRepo)->cstatus->df) <= 0)) {
+    pRepo->deleteState = TSDB_NO_DELETE;
+    tsem_post(&(pRepo->readyToCommit));
+    tsdbInfo("vgId:%d :SDEL delete over, no meta or data file", REPO_ID(pRepo));
+    return -1;
+  }
+
+  SArray* aUpdates = taosArrayInit(10, sizeof(STable *));
+  SArray* affectedTables = taosArrayInit(10, sizeof(int32_t)); // put tid
+
+  // start transaction
+  tsdbStartDeleteTrans(pRepo);
+
+  int32_t ret = tsdbInitNewMFile(pRepo);
+  if (ret != TSDB_CODE_SUCCESS) {
+    tsdbError("vgId:%d :SDEL failed errcode=%d to init new META", REPO_ID(pRepo), ret);
+    goto _err;
+  }
+
+  ret = tsdbDeleteTSData(pRepo, pCtlInfo, aUpdates, affectedTables);
+  if (ret != TSDB_CODE_SUCCESS) {
+    tsdbError("vgId:%d :SDEL failed to delete TS data errcode=%d since %s", REPO_ID(pRepo), ret, tstrerror(terrno));
+    goto _err;
+  }
+
+  tsdbInfo("vgId:%d :SDEL Deleted %d row(s) from %d table(s)", REPO_ID(pRepo), pCtlInfo->affectedRows, (int32_t)taosArrayGetSize(affectedTables));
+
+  // end transaction
+  tsdbEndDeleteTrans(pRepo, TSDB_CODE_SUCCESS);
+
+  // set affected tables number
+  if(pCtlInfo->pRsp) {
+    pCtlInfo->pRsp->numOfTables  = (int32_t)taosArrayGetSize(affectedTables);
+    pCtlInfo->pRsp->affectedRows = pCtlInfo->affectedRows;
+  }
+
+  // update last row
+  tsdbUpdateLastRow(pRepo, aUpdates);
+  tsdbClearUpdates(aUpdates);
+  taosArrayDestroy(&affectedTables);
+  return TSDB_CODE_SUCCESS;
+
+_err:
+  pRepo->code = ret;
+  tsdbEndDeleteTrans(pRepo, ret);
+  tsdbClearUpdates(aUpdates);
+  taosArrayDestroy(&affectedTables);
+  return TSDB_CODE_SUCCESS; // other error needn't call appH.notifyStatus to notify error 
+  //return ret;
+}
+
+static void tsdbStartDeleteTrans(STsdbRepo *pRepo) {
+  assert(pRepo->deleteState != TSDB_IN_DELETE);
+  tsdbInfo("vgId:%d :SDEL start delete transaction!", REPO_ID(pRepo));
+  tsdbStartFSTxn(pRepo, 0, 0);
+  pRepo->code = TSDB_CODE_SUCCESS;
+  pRepo->deleteState = TSDB_IN_DELETE;
+}
+
+static void tsdbEndDeleteTrans(STsdbRepo *pRepo, int eno) {
+  if (eno != TSDB_CODE_SUCCESS) {
+    tsdbEndFSTxnWithError(REPO_FS(pRepo));
+  } else {
+    tsdbEndFSTxn(pRepo);
+  }
+  pRepo->deleteState = TSDB_NO_DELETE;
+  tsdbInfo("vgId:%d :SDEL end delete transaction, %s", REPO_ID(pRepo), (eno == TSDB_CODE_SUCCESS) ? "succeed" : "failed");
+}
+
+static int tsdbDeleteTSData(STsdbRepo *pRepo, SControlDataInfo* pCtlInfo, SArray* pArray, SArray* pAffectTables) {
+  STsdbCfg *       pCfg = REPO_CFG(pRepo);
+  SDeleteH         deleteH = {0};
+  SDFileSet *      pSet = NULL;
+  int32_t          numSet = 0;
+
+  if (tsdbInitDeleteH(&deleteH, pRepo) < 0) {
+    return -1;
+  }
+
+  deleteH.aUpdates = pArray;
+  deleteH.pCtlInfo = pCtlInfo;
+  STimeWindow win  = pCtlInfo->win;
+  deleteH.aAffectTables = pAffectTables;
+
+  int sFid = TSDB_KEY_FID(win.skey, pCfg->daysPerFile, pCfg->precision);
+  int eFid = TSDB_KEY_FID(win.ekey, pCfg->daysPerFile, pCfg->precision);
+  if(sFid > eFid) {
+    tsdbError("vgId:%d :SDEL sFid > eFid no fid to delete. sFid=%d eFid=%d", REPO_ID(pRepo), sFid, eFid);
+    tsdbDestroyDeleteH(&deleteH);
+    return -1;
+  }
+
+  while ((pSet = tsdbFSIterNext(&(deleteH.fsIter)))) {
+    // remove expired files
+    if (pSet->fid < deleteH.rtn.minFid) {
+      tsdbInfo("vgId:%d :SDEL FSET %d on level %d disk id %d expires, remove it", REPO_ID(pRepo), pSet->fid,
+               TSDB_FSET_LEVEL(pSet), TSDB_FSET_ID(pSet));
+      continue;
+    }
+
+    if ((pSet->fid < sFid) || (pSet->fid > eFid)) {
+      tsdbDebug("vgId:%d :SDEL no need to delete FSET %d, sFid %d, eFid %d", REPO_ID(pRepo), pSet->fid, sFid, eFid);
+      if (tsdbApplyRtnOnFSet(pRepo, pSet, &(deleteH.rtn)) < 0) {
+        return -1;
+      }
+      continue;
+    }
+    
+    if (pCtlInfo->command & CMD_DELETE_DATA) {
+      if (tsdbFSetDelete(&deleteH, pSet) < 0) {
+        tsdbDestroyDeleteH(&deleteH);
+        tsdbError("vgId:%d :SDEL failed to delete data in FSET %d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+        return -1;
+      }
+      numSet++;
+    }
+  }
+
+  tsdbDestroyDeleteH(&deleteH);
+  if (numSet == 0 || pCtlInfo->affectedRows == 0) {
+    tsdbInfo("vgId:%d :SDEL zero num FSet to delete.", REPO_ID(pRepo));
+    return -1;
+  }
+
+  return 0;
+}
+
+static int tsdbSDFileCreate(STsdbRepo* pRepo, SDFileSet *pWSet, SDFileSet *pSet, SDiskID did, TSDB_FILE_T ftype) {
+  SDFile *pSDFile = TSDB_DFILE_IN_SET(pWSet, ftype);
+  tsdbInitDFile(pSDFile, did, REPO_ID(pRepo), TSDB_FSET_FID(pSet), FS_VERSION(REPO_FS(pRepo)), ftype);
+
+  struct stat st;
+  if (stat(pSDFile->f.aname, &st) == 0) {
+    tsdbError("vgId:%d :SDEL file exist no need create fid=%d name=%s", REPO_ID(pRepo), pSet->fid, pSDFile->f.aname);
+    return 0;
+  }
+
+  if (tsdbCreateDFile(pSDFile, true, ftype) < 0) {
+    tsdbError("vgId:%d :SDEL failed to delete table in FSET %d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+    tsdbCloseDFile(pSDFile);
+    tsdbRemoveDFile(pSDFile);
+    return -1;
+  }
+  tsdbCloseDFile(pSDFile);
+  return 0;
+}
+
+static int tsdbFSetDelete(SDeleteH *pdh, SDFileSet *pSet) {
+  STsdbRepo *pRepo = TSDB_DELETE_REPO(pdh);
+  SDiskID    did = {0};
+  SDFileSet *pWSet = TSDB_DELETE_WSET(pdh);
+
+  tsdbDebug("vgId:%d :SDEL start to delete data in FSET %d on level %d id %d", REPO_ID(pRepo), pSet->fid,
+            TSDB_FSET_LEVEL(pSet), TSDB_FSET_ID(pSet));
+
+  if (tsdbFSetInit(pdh, pSet) < 0) {
+    tsdbError("vgId:%d :SDEL fset init failed. FSET %d on level %d id %d", REPO_ID(pRepo), pSet->fid,
+            TSDB_FSET_LEVEL(pSet), TSDB_FSET_ID(pSet));
+    return -1;
+  }
+
+  // Create new fset as deleted fset
+  tfsAllocDisk(tsdbGetFidLevel(pSet->fid, &(pdh->rtn)), &(did.level), &(did.id));
+  if (did.level == TFS_UNDECIDED_LEVEL) {
+    terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
+    tsdbError("vgId:%d :SDEL failed to delete table in FSET %d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+    tsdbFSetEnd(pdh);
+    return -1;
+  }
+
+  // Only .head is created, use original .data/.last/.smad/.smal
+  tsdbInitDFileSetEx(pWSet, pSet);
+  pWSet->state = 0;
+
+  // old pset
+  if(pWSet->ver == TSDB_FSET_VER_0) {
+    tsdbDebug("vgId:%d :SDEL pWSet is ver0. fid=%d", REPO_ID(pRepo), pSet->fid);
+    if(tsdbSDFileCreate(pRepo, pWSet, pSet, did, TSDB_FILE_SMAD) < 0 ) {
+      tsdbError("vgId:%d :SDEL failed to create sma files. fid=%d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+      tsdbFSetEnd(pdh);
+      return -1;
+    }
+    if(tsdbSDFileCreate(pRepo, pWSet, pSet, did, TSDB_FILE_SMAL) < 0 ) {
+      tsdbError("vgId:%d :SDEL failed to create sma files. fid=%d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+      tsdbFSetEnd(pdh);
+      return -1;
+    }
+    pWSet->ver = TSDB_FS_VER_1;
+  }
+
+  // create new .head file  FS_TXN_VERSION is nstatus.meta.version, so version is +=1
+  SDFile *pHeadFile = TSDB_DFILE_IN_SET(pWSet, TSDB_FILE_HEAD);
+  tsdbInitDFile(pHeadFile, did, REPO_ID(pRepo), TSDB_FSET_FID(pSet), FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_FILE_HEAD);
+  if (tsdbCreateDFile(pHeadFile, true, TSDB_FILE_HEAD) < 0) {
+    tsdbError("vgId:%d :SDEL failed to delete table in FSET %d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
+    tsdbCloseDFile(pHeadFile);
+    tsdbRemoveDFile(pHeadFile);
+    tsdbFSetEnd(pdh);
+    return -1;
+  }
+  tsdbCloseDFile(pHeadFile);
+
+  if (tsdbOpenDFileSet(pWSet, O_RDWR) < 0) {
+    tsdbError("vgId:%d :SDEL failed to open file set %d since %s", REPO_ID(pRepo), TSDB_FSET_FID(pWSet), tstrerror(terrno));
+    tsdbCloseDFile(pHeadFile);
+    tsdbRemoveDFile(pHeadFile);
+    tsdbFSetEnd(pdh);
+    return -1;
+  }
+
+  if (tsdbFSetDeleteImpl(pdh) < 0) {
+    tsdbCloseDFileSet(TSDB_DELETE_WSET(pdh));
+    tsdbRemoveDFileSet(TSDB_DELETE_WSET(pdh));
+    tsdbFSetEnd(pdh);
+    return -1;
+  }
+
+  tsdbCloseDFileSet(TSDB_DELETE_WSET(pdh));
+  tsdbUpdateDFileSet(REPO_FS(pRepo), TSDB_DELETE_WSET(pdh));
+  tsdbDebug("vgId:%d :SDEL FSET %d delete data over", REPO_ID(pRepo), pSet->fid);
+
+  tsdbFSetEnd(pdh);
+  return 0;
+}
+
+static int tsdbInitDeleteH(SDeleteH *pdh, STsdbRepo *pRepo) {
+  STsdbCfg *pCfg = REPO_CFG(pRepo);
+
+  memset(pdh, 0, sizeof(*pdh));
+
+  TSDB_FSET_SET_CLOSED(TSDB_DELETE_WSET(pdh));
+  pdh->pRepo = pRepo;
+
+  tsdbGetRtnSnap(pRepo, &(pdh->rtn));
+  tsdbFSIterInit(&(pdh->fsIter), REPO_FS(pRepo), TSDB_FS_ITER_FORWARD);
+
+  if (tsdbInitReadH(&(pdh->readh), pRepo) < 0) {
+    tsdbError("vgId:%d :SDEL tsdbInitReadH return -1. malloc memory failed.", REPO_ID(pRepo));
+    return -1;
+  }
+
+  if (tsdbInitDeleteTblArray(pdh) < 0) {
+    tsdbError("vgId:%d :SDEL tsdbInitDeleteTblArray return -1. maybe malloc memory failed or lock meta error.", REPO_ID(pRepo));
+    tsdbDestroyDeleteH(pdh);
+    return -1;
+  }
+
+  pdh->aBlkIdx = taosArrayInit(1024, sizeof(SBlockIdx));
+  if (pdh->aBlkIdx == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tsdbDestroyDeleteH(pdh);
+    return -1;
+  }
+
+  pdh->aSupBlk = taosArrayInit(1024, sizeof(SBlock));
+  if (pdh->aSupBlk == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tsdbDestroyDeleteH(pdh);
+    return -1;
+  }
+
+  pdh->aSubBlk = taosArrayInit(20, sizeof(SBlock));
+  if (pdh->aSubBlk == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tsdbDestroyDeleteH(pdh);
+    return -1;
+  }
+
+  pdh->pDCols = tdNewDataCols(0, pCfg->maxRowsPerFileBlock);
+  if (pdh->pDCols == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tsdbDestroyDeleteH(pdh);
+    return -1;
+  }
+
+  return 0;
+}
+
+static void tsdbDestroyDeleteH(SDeleteH *pdh) {
+  pdh->pDCols = tdFreeDataCols(pdh->pDCols);
+  pdh->aSupBlk = taosArrayDestroy(&pdh->aSupBlk);
+  pdh->aSubBlk = taosArrayDestroy(&pdh->aSubBlk);
+  pdh->aBlkIdx = taosArrayDestroy(&pdh->aBlkIdx);
+  tsdbDestroyDeleteTblArray(pdh);
+  tsdbDestroyReadH(&(pdh->readh));
+  tsdbCloseDFileSet(TSDB_DELETE_WSET(pdh));
+}
+
+void tsdbAddUpdates(SArray* pArray, STable* pTable) {
+  size_t cnt = taosArrayGetSize(pArray);
+  for ( size_t i = 0; i < cnt; i++) {
+   STable* pt = taosArrayGetP(pArray, i);
+   if ( pt == pTable) {
+     // found
+     return ;
+   }
+  }
+  // ref count ++
+  tsdbRefTable(pTable);
+  // append
+  taosArrayAddBatch(pArray, &pTable, 1);
+}
+
+void tsdbAddAffectTables(SArray* pArray, int32_t tid) {
+  size_t cnt = taosArrayGetSize(pArray);
+  for ( size_t i = 0; i < cnt; i++) {
+   int32_t tid1 = *(int32_t *)taosArrayGet(pArray, i);
+   if ( tid1 == tid) {
+     // exist return
+     return ;
+   }
+  }
+  // append
+  taosArrayAddBatch(pArray, &tid, 1);
+}
+// init tbl array with pRepo->meta
+static int tsdbInitDeleteTblArray(SDeleteH *pdh) {
+  STsdbRepo *pRepo = TSDB_DELETE_REPO(pdh);
+  STsdbMeta *pMeta = pRepo->tsdbMeta;
+
+  if (tsdbRLockRepoMeta(pRepo) < 0) return -1;
+
+  pdh->tblArray = taosArrayInit(pMeta->maxTables, sizeof(STableDeleteH));
+  if (pdh->tblArray == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tsdbUnlockRepoMeta(pRepo);
+    return -1;
+  }
+
+  // Note here must start from 0
+  for (int i = 0; i < pMeta->maxTables; ++i) {
+    STableDeleteH tbl = {0};
+    if (pMeta->tables[i] != NULL) {
+      tsdbRefTable(pMeta->tables[i]);
+      tbl.pTable = pMeta->tables[i];
+    }
+
+    if (taosArrayPush(pdh->tblArray, &tbl) == NULL) {
+      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+      tsdbUnlockRepoMeta(pRepo);
+      return -1;
+    }
+  }
+
+  if (tsdbUnlockRepoMeta(pRepo) < 0) return -1;
+  return 0;
+}
+
+static void tsdbDestroyDeleteTblArray(SDeleteH *pdh) {
+  STableDeleteH *pItem = NULL;
+
+  if (pdh->tblArray == NULL) return;
+
+  for (size_t i = 0; i < taosArrayGetSize(pdh->tblArray); ++i) {
+    pItem = (STableDeleteH *)taosArrayGet(pdh->tblArray, i);
+    if (pItem->pTable) {
+      tsdbUnRefTable(pItem->pTable);
+    }
+
+    tfree(pItem->pInfo);
+  }
+
+  pdh->tblArray = taosArrayDestroy(&pdh->tblArray);
+}
+
+static int tsdbCacheFSetIndex(SDeleteH *pdh) {
+  SReadH *pReadH = &(pdh->readh);
+
+  if (tsdbLoadBlockIdx(pReadH) < 0) {
+    return -1;
+  }
+
+  size_t cnt = taosArrayGetSize(pdh->tblArray);
+  for (size_t tid = 1; tid < cnt; ++tid) {
+    STableDeleteH *pItem = (STableDeleteH *)taosArrayGet(pdh->tblArray, tid);
+    pItem->pBlkIdx = NULL;
+
+    if (pItem->pTable == NULL) 
+      continue;
+    if (tsdbSetReadTable(pReadH, pItem->pTable) < 0)
+      return -1;
+    if (pReadH->pBlkIdx == NULL) 
+      continue;
+    pItem->bIndex = *(pReadH->pBlkIdx);
+    pItem->pBlkIdx = &(pItem->bIndex);
+
+    uint32_t originLen = 0;
+    if (tsdbLoadBlockInfo(pReadH, (void **)(&(pItem->pInfo)), &originLen) < 0) {
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+static int tsdbFSetInit(SDeleteH *pdh, SDFileSet *pSet) {
+  taosArrayClear(pdh->aBlkIdx);
+  taosArrayClear(pdh->aSupBlk);
+
+  // open
+  if (tsdbSetAndOpenReadFSet(&(pdh->readh), pSet) < 0) {
+    return -1;
+  }
+
+  // load index to cache
+  if (tsdbCacheFSetIndex(pdh) < 0) {
+    tsdbCloseAndUnsetFSet(&(pdh->readh));
+    return -1;
+  }
+
+  return 0;
+}
+
+static void tsdbFSetEnd(SDeleteH *pdh) { 
+  tsdbCloseAndUnsetFSet(&(pdh->readh)); 
+}
+
+static int32_t tsdbFilterDataCols(SDeleteH *pdh, SDataCols *pSrcDCols) {
+  SDataCols * pDstDCols = pdh->pDCols;
+  int32_t delRows = 0;
+
+  tdResetDataCols(pDstDCols);
+  pDstDCols->sversion = pSrcDCols->sversion;
+
+  for (int i = 0; i < pSrcDCols->numOfRows; ++i) {
+    int64_t tsKey = *(int64_t *)tdGetColDataOfRow(pSrcDCols->cols, i);
+    if ((tsKey >= pdh->pCtlInfo->win.skey) && (tsKey <= pdh->pCtlInfo->win.ekey)) {
+      // delete row
+      delRows ++;
+      continue;
+    }
+    for (int j = 0; j < pSrcDCols->numOfCols; ++j) {
+      if (pSrcDCols->cols[j].len > 0 || pDstDCols->cols[j].len > 0) {
+        dataColAppendVal(pDstDCols->cols + j, tdGetColDataOfRow(pSrcDCols->cols + j, i), pDstDCols->numOfRows,
+                         pDstDCols->maxPoints, 0);
+      }
+    }
+    ++ pDstDCols->numOfRows;
+  }
+
+  return delRows;
+}
+
+// table in delete list
+bool tableInDel(SDeleteH* pdh, int32_t tid) {
+  for (int32_t i = 0; i < pdh->pCtlInfo->tnum; i++) {
+    if (tid == pdh->pCtlInfo->tids[i])
+      return true;
+  }
+
+  return false;
+}
+
+// if pBlock is border block return true else return false
+static int tsdbBlockSolve(SDeleteH *pdh, SBlock *pBlock) {
+  // delete window
+  STimeWindow* pdel = &pdh->pCtlInfo->win;
+
+  // do nothing for no delete
+  if(pBlock->keyFirst > pdel->ekey || pBlock->keyLast < pdel->skey)
+    return BLOCK_READ;
+
+  // border block
+  if(pBlock->keyFirst <= pdel->skey || pBlock->keyLast >= pdel->ekey)
+    return BLOCK_MODIFY;
+
+  // need del
+  return BLOCK_DELETE;
+}
+
+// remove del block from pBlockInfo
+int tsdbRemoveDelBlocks(SDeleteH *pdh, STableDeleteH * pItem) {
+  // loop
+  int numOfBlocks = pItem->pBlkIdx->numOfBlocks;
+  int from = -1;
+  int delRows = 0;
+  
+  for (int i = numOfBlocks - 1; i >= 0; --i) {
+    SBlock *pBlock = pItem->pInfo->blocks + i;
+    int32_t solve = tsdbBlockSolve(pdh, pBlock);
+    if (solve == BLOCK_DELETE) {
+      if (from == -1)
+         from = i;
+      delRows += pBlock->numOfRows;   
+    } else {
+      if(from != -1) {
+        // do del
+        int delCnt = from - i;
+        memmove(pItem->pInfo->blocks + i + 1, pItem->pInfo->blocks + i + 1 + delCnt, (numOfBlocks - (i+1) - delCnt) * sizeof(SBlock));
+        numOfBlocks -= delCnt;
+        from = -1;
+      }
+    }
+  }
+
+  if(from != -1) {
+    int delCnt = from + 1;
+    memmove(pItem->pInfo->blocks, pItem->pInfo->blocks + delCnt, (numOfBlocks - delCnt) * sizeof(SBlock));
+    numOfBlocks -= delCnt;
+  }
+
+  // set current blocks num
+  pItem->pBlkIdx->numOfBlocks = numOfBlocks;
+
+  if(delRows > 0) {
+    // affected Rows
+    pdh->pCtlInfo->affectedRows += delRows;
+    // affected Tables
+    tsdbAddAffectTables(pdh->aAffectTables, pItem->pTable->tableId.tid);
+  }  
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static void tsdbAddBlock(SDeleteH *pdh, STableDeleteH *pItem, SBlock *pBlock) {
+  // append sub if have
+  if (pBlock->numOfSubBlocks > 1) {
+    int64_t offset = taosArrayGetSize(pdh->aSubBlk) * sizeof(SBlock);
+    SBlock *jBlock = POINTER_SHIFT(pItem->pInfo, pBlock->offset);;
+    for (int j = 0; j < pBlock->numOfSubBlocks; j++) {
+      taosArrayPush(pdh->aSubBlk, (const void *)jBlock++);
+    }
+    // set new offset if have sub
+    pBlock->offset = offset;
+  }
+
+  // append super
+  taosArrayPush(pdh->aSupBlk, (const void *)pBlock);
+}
+
+// need modify blocks
+static int tsdbModifyBlocks(SDeleteH *pdh, STableDeleteH *pItem) {
+  SReadH *   pReadh  = &(pdh->readh);
+  void **    ppBuf   = &(TSDB_DELETE_BUF(pdh));
+  void **    ppCBuf  = &(TSDB_DELETE_COMP_BUF(pdh));
+  void **    ppExBuf = &(TSDB_DELETE_EXBUF(pdh));
+  STSchema  *pSchema = NULL;
+  SBlockIdx  blkIdx  = {0};
+
+  // update last row if need
+  TSKEY lastKey = pItem->pTable->lastKey;
+  if(lastKey >= pdh->pCtlInfo->win.skey && lastKey <= pdh->pCtlInfo->win.ekey) {
+    // update lastkey and lastrow
+    tsdbAddUpdates(pdh->aUpdates, pItem->pTable);
+  }
+
+  // get pSchema for del table
+  if ((pSchema = tsdbGetTableSchemaImpl(pItem->pTable, true, true, -1, -1)) == NULL) {
+    tsdbError("vgId:%d :SDEL tsdbGetTableSchemaImpl return NULL tid=%d. errno=%d (%s)", REPO_ID(pdh->pRepo),
+              pItem->pTable->tableId.tid,  errno, tstrerror(terrno));
+    return -1;
+  }
+  
+  if ((tdInitDataCols(pdh->pDCols, pSchema) < 0) || (tdInitDataCols(pReadh->pDCols[0], pSchema) < 0) ||
+      (tdInitDataCols(pReadh->pDCols[1], pSchema) < 0)) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    tdFreeSchema(pSchema);
+    return -1;
+  }
+  tdFreeSchema(pSchema);
+
+  // delete block
+  tsdbRemoveDelBlocks(pdh, pItem);
+  if(pItem->pBlkIdx->numOfBlocks == 0) {
+    // all blocks were deleted
+    return TSDB_CODE_SUCCESS;
+  }
+
+  taosArrayClear(pdh->aSupBlk);
+  taosArrayClear(pdh->aSubBlk);
+
+  int32_t affectedRows = 0;
+
+  // Loop to delete each block data
+  for (int i = 0; i < pItem->pBlkIdx->numOfBlocks; ++i) {
+    SBlock *pBlock = pItem->pInfo->blocks + i;
+    int32_t solve = tsdbBlockSolve(pdh, pBlock);
+    if (solve == BLOCK_READ) {
+      tsdbAddBlock(pdh, pItem, pBlock);
+      continue;
+    }
+
+    // border block need load to delete no-use data
+    if (tsdbLoadBlockData(pReadh, pBlock, pItem->pInfo) < 0) {
+      tsdbError("vgId:%d :SDEL tsdbLoadBlockData return -1. i=%d. errno=%d (%s)", REPO_ID(pdh->pRepo), i, errno, tstrerror(terrno));
+      return -1;
+    }
+
+    affectedRows += tsdbFilterDataCols(pdh, pReadh->pDCols[0]);
+    if (pdh->pDCols->numOfRows <= 0) {
+      continue;
+    }
+
+    SBlock newBlock = {0};
+    if (tsdbWriteBlockToFile(pdh, pItem->pTable, pdh->pDCols, ppBuf, ppCBuf, ppExBuf, &newBlock) < 0) {
+      tsdbError("vgId:%d :SDEL tsdbWriteBlockToFile return -1. i=%d. errno=%d (%s)", REPO_ID(pdh->pRepo), i, errno, tstrerror(terrno));
+      return -1;
+    }
+
+    // add new block to info
+    tsdbAddBlock(pdh, pItem, &newBlock);
+  }
+
+  // write block info for each table
+  if (tsdbWriteBlockInfoImpl(TSDB_DELETE_HEAD_FILE(pdh), pItem->pTable, pdh->aSupBlk, pdh->aSubBlk,
+                              ppBuf, &blkIdx) < 0) {
+    tsdbError("vgId:%d :SDEL tsdbWriteBlockInfoImpl return -1. tid=%d. errno=%d (%s)", REPO_ID(pdh->pRepo),
+              pItem->pTable->tableId.tid,  errno, tstrerror(terrno));
+    return -1;
+  }
+
+  // each table's blkIdx 
+  if (blkIdx.numOfBlocks > 0 && taosArrayPush(pdh->aBlkIdx, (const void *)(&blkIdx)) == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  // update new last row in last row was deleted
+  if (affectedRows > 0) {
+    // affectedRows
+    pdh->pCtlInfo->affectedRows += affectedRows;
+    // affectTables
+    tsdbAddAffectTables(pdh->aAffectTables, pItem->pTable->tableId.tid);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+// keep intact blocks info and write to head file then save offset to blkIdx
+static int tsdbKeepIntactBlocks(SDeleteH *pdh, STableDeleteH * pItem) {
+  // init
+  SBlockIdx  blkIdx  = {0};
+  taosArrayClear(pdh->aSupBlk);
+  taosArrayClear(pdh->aSubBlk);
+
+  for (int32_t i = 0; i < pItem->pBlkIdx->numOfBlocks; i++) {
+    SBlock *pBlock = pItem->pInfo->blocks + i;
+    tsdbAddBlock(pdh, pItem, pBlock);
+  }
+
+  // write block info for one table
+  void **ppBuf = &(TSDB_DELETE_BUF(pdh));
+  int32_t ret  = tsdbWriteBlockInfoImpl(TSDB_DELETE_HEAD_FILE(pdh), pItem->pTable, pdh->aSupBlk, 
+                                       pdh->aSubBlk, ppBuf, &blkIdx);
+  if (ret != TSDB_CODE_SUCCESS) {
+    return ret;
+  }
+
+  // each table's blkIdx 
+  if (blkIdx.numOfBlocks > 0 && taosArrayPush(pdh->aBlkIdx, (const void *)&blkIdx) == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  return ret;
+}
+
+static int tsdbFSetDeleteImpl(SDeleteH *pdh) {
+  void **   ppBuf  = &(TSDB_DELETE_BUF(pdh));
+  int32_t   ret    = TSDB_CODE_SUCCESS;
+
+  // 1.INIT
+  taosArrayClear(pdh->aBlkIdx);
+
+  for (size_t tid = 1; tid < taosArrayGetSize(pdh->tblArray); ++tid) {
+    STableDeleteH *pItem = (STableDeleteH *)taosArrayGet(pdh->tblArray, tid);
+
+    // no table in this tid position
+    if (pItem->pTable == NULL || pItem->pBlkIdx == NULL)
+      continue;
+
+    // 2.WRITE INFO OF EACH TABLE BLOCK INFO TO HEAD FILE
+    if (tableInDel(pdh, (int32_t)tid)) {
+      // modify blocks info and write to head file then save offset to blkIdx
+      ret = tsdbModifyBlocks(pdh, pItem);
+    } else {
+      // keep intact blocks info and write to head file then save offset to blkIdx
+      ret = tsdbKeepIntactBlocks(pdh, pItem);
+    }
+    if (ret != TSDB_CODE_SUCCESS)
+      return ret;
+  } // tid for
+
+  // 3.WRITE INDEX OF ALL TABLE'S BLOCK TO HEAD FILE
+  if (tsdbWriteBlockIdx(TSDB_DELETE_HEAD_FILE(pdh), pdh->aBlkIdx, ppBuf) < 0) {
+    tsdbError("vgId:%d :SDEL tsdbWriteBlockIdx return -1. errno=%d (%s)", REPO_ID(pdh->pRepo), terrno, tstrerror(terrno));
+    return -1;
+  }
+
+  return ret;
+}
+
+static int tsdbWriteBlockToFile(SDeleteH *pdh, STable *pTable, SDataCols *pDCols, void **ppBuf,
+                                     void **ppCBuf, void **ppExBuf, SBlock *pBlock) {
+  STsdbRepo *pRepo = TSDB_DELETE_REPO(pdh);
+  STsdbCfg * pCfg = REPO_CFG(pRepo);
+  SDFile *   pDFile = NULL;
+  bool       isLast = false;
+
+  ASSERT(pDCols->numOfRows > 0);
+
+  if (pDCols->numOfRows < pCfg->minRowsPerFileBlock) {
+    pDFile = TSDB_DELETE_LAST_FILE(pdh);
+    isLast = true;
+  } else {
+    pDFile = TSDB_DELETE_DATA_FILE(pdh);
+    isLast = false;
+  }
+
+  if (tsdbWriteBlockImpl(pRepo, pTable, pDFile,
+                         isLast ? TSDB_DELETE_SMAL_FILE(pdh) : TSDB_DELETE_SMAD_FILE(pdh), pDCols,
+                         pBlock, isLast, true, ppBuf, ppCBuf, ppExBuf) < 0) {
+    return -1;
+  }
+
+  return 0;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 45872b1dcef5904e269b2fda6fb4aa5cb3b26a9b..2ae215ad36288349c41d18ad000823063da37805 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -30,7 +30,6 @@ static void       tsdbFreeRepo(STsdbRepo *pRepo);
 static void       tsdbStartStream(STsdbRepo *pRepo);
 static void       tsdbStopStream(STsdbRepo *pRepo);
 static int        tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh);
-static int        tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx);
 
 // Function declaration
 int32_t tsdbCreateRepo(int repoid) {
@@ -188,7 +187,7 @@ int tsdbUnlockRepo(STsdbRepo *pRepo) {
 int tsdbCheckWal(STsdbRepo *pRepo, uint32_t walSize) {  // MB
   STsdbCfg *pCfg = &(pRepo->config);
   if ((walSize > tsdbWalFlushSize) && (walSize > (pCfg->totalBlocks / 2 * pCfg->cacheBlockSize))) {
-    if (tsdbAsyncCommit(pRepo) < 0) return -1;
+    if (tsdbAsyncCommit(pRepo, NULL) < 0) return -1;
   }
   return 0;
 }
@@ -202,7 +201,7 @@ int tsdbCheckCommit(STsdbRepo *pRepo) {
   if ((pRepo->mem->extraBuffList != NULL) ||
       ((listNEles(pRepo->mem->bufBlockList) >= pCfg->totalBlocks / 3) && (pBufBlock->remain < TSDB_BUFFER_RESERVE))) {
     // trigger commit
-    if (tsdbAsyncCommit(pRepo) < 0) return -1;
+    if (tsdbAsyncCommit(pRepo, NULL) < 0) return -1;
   }
   return 0;
 }
@@ -215,6 +214,8 @@ int tsdbGetState(STsdbRepo *repo) { return repo->state; }
 
 int8_t tsdbGetCompactState(STsdbRepo *repo) { return (int8_t)(repo->compactState); }
 
+int8_t tsdbGetDeleteState(STsdbRepo *repo) { return (int8_t)(repo->deleteState); }
+
 void tsdbReportStat(void *repo, int64_t *totalPoints, int64_t *totalStorage, int64_t *compStorage) {
   ASSERT(repo != NULL);
   STsdbRepo *pRepo = repo;
@@ -574,6 +575,7 @@ static STsdbRepo *tsdbNewRepo(STsdbCfg *pCfg, STsdbAppH *pAppH) {
   pRepo->state = TSDB_STATE_OK;
   pRepo->code = TSDB_CODE_SUCCESS;
   pRepo->compactState = 0;
+  pRepo->deleteState = 0;
   pRepo->config = *pCfg;
   if (pAppH) {
     pRepo->appH = *pAppH;
@@ -811,8 +813,7 @@ out:
   return err;
 }
 
-static int tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx) {
-  ASSERT(pTable->lastRow == NULL);
+int tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx, bool onlyKey) {
   if (tsdbLoadBlockInfo(pReadh, NULL, NULL) < 0) {
     return -1;
   }
@@ -841,17 +842,24 @@ static int tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh,
   }
 
   TSKEY lastKey = memRowKey(lastRow);
-  
   // during the load data in file, new data would be inserted and last row has been updated
   TSDB_WLOCK_TABLE(pTable);
-  if (pTable->lastRow == NULL) {
-    pTable->lastKey = lastKey;
-    pTable->lastRow = lastRow;
-    TSDB_WUNLOCK_TABLE(pTable);
+
+  pTable->lastKey = lastKey;
+  if (!onlyKey) {
+    // set
+    if (pTable->lastRow) {
+      SMemRow* p = pTable->lastRow;
+      pTable->lastRow = lastRow;
+      taosTZfree(p);
+    } else {
+      pTable->lastRow = lastRow;
+    }
   } else {
-    TSDB_WUNLOCK_TABLE(pTable);
     taosTZfree(lastRow);
   }
+ 
+  TSDB_WUNLOCK_TABLE(pTable);
 
   return 0;
 }
@@ -905,7 +913,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       if (pIdx && lastKey < pIdx->maxKey) {
         pTable->lastKey = pIdx->maxKey;
 
-        if (CACHE_LAST_ROW(pCfg) && tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx) != 0) {
+        if (CACHE_LAST_ROW(pCfg) && tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx, false) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
         }
@@ -930,7 +938,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
   return 0;
 }
 
-int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable) {
+int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable, bool force) {
   SFSIter    fsiter;
   SReadH     readh;
   SDFileSet *pSet;
@@ -939,6 +947,7 @@ int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable) {
 
   bool cacheLastRow = CACHE_LAST_ROW(&(pRepo->config));
   bool cacheLastCol = CACHE_LAST_NULL_COLUMN(&(pRepo->config));
+  bool onlyKey = !cacheLastRow;
 
   tsdbDebug("tsdbLoadLastCache for %s, cacheLastRow:%d, cacheLastCol:%d", pTable->name->data, cacheLastRow, cacheLastCol);
 
@@ -948,19 +957,24 @@ int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable) {
     taosTZfree(pTable->lastRow);
     pTable->lastRow = NULL;
   }
-  if (!cacheLastCol && pTable->lastCols != NULL) {
+  if ((!cacheLastCol && pTable->lastCols != NULL) || force) {
     tsdbFreeLastColumns(pTable);
   }
 
-  if (!cacheLastRow && !cacheLastCol) {
-    return 0;
+  if (!cacheLastRow && !cacheLastCol && !force) {
+      return 0;
   }
 
   cacheLastRowTableNum = (cacheLastRow && pTable->lastRow  == NULL) ? 1 : 0;
   cacheLastColTableNum = (cacheLastCol && pTable->lastCols == NULL) ? 1 : 0;
 
-  if (cacheLastRowTableNum == 0 && cacheLastColTableNum == 0) {
-    return 0;
+  if(force && cacheLastRowTableNum == 0) {
+    // if force update , must set 1
+    cacheLastRowTableNum = 1;
+  }
+
+  if (cacheLastRowTableNum == 0 && cacheLastColTableNum == 0 && !force) {
+      return 0;
   }
 
   if (tsdbInitReadH(&readh, pRepo) < 0) {
@@ -993,8 +1007,8 @@ int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable) {
 
     SBlockIdx *pIdx = readh.pBlkIdx;
 
-    if (pIdx && (cacheLastRowTableNum > 0) && (pTable->lastRow == NULL)) {
-      if (tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx) != 0) {
+    if (pIdx && (cacheLastRowTableNum > 0) && (pTable->lastRow == NULL || force)) {
+      if (tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx, onlyKey) != 0) {
         tsdbUnLockFS(REPO_FS(pRepo));
         tsdbDestroyReadH(&readh);
         return -1;
@@ -1015,6 +1029,13 @@ int32_t tsdbLoadLastCache(STsdbRepo *pRepo, STable *pTable) {
     }
   }
 
+  if ( cacheLastRowTableNum > 0 && readh.pBlkIdx == NULL) {
+    // table no data, so reset lastKey
+    TSDB_WLOCK_TABLE(pTable);
+    pTable->lastKey = TSKEY_INITIAL_VAL;
+    TSDB_WUNLOCK_TABLE(pTable);
+  }
+
   tsdbUnLockFS(REPO_FS(pRepo));
   tsdbDestroyReadH(&readh);
 
@@ -1113,7 +1134,7 @@ UNUSED_FUNC int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
       if (pIdx && cacheLastRowTableNum > 0 && pTable->lastRow == NULL) {                
         pTable->lastKey = pIdx->maxKey;
 
-        if (tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx) != 0) {
+        if (tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx, false) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
         }
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 8958df3ced9a1577735660293eda0717b46db49a..bf34c1e88d30f2259ea63ab71c46930fab2a75f7 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -15,9 +15,9 @@
 
 #include "tdataformat.h"
 #include "tfunctional.h"
-#include "tsdbint.h"
 #include "tskiplist.h"
 #include "tsdbRowMergeBuf.h"
+#include "tsdbint.h"
 
 #define TSDB_DATA_SKIPLIST_LEVEL 5
 #define TSDB_MAX_INSERT_BATCH 512
@@ -49,15 +49,17 @@ static int          tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIte
 static int          tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock);
 static int          tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable);
 static int          tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SMemRow row);
+static int32_t      tsdbInsertControlData(STsdbRepo* pRepo, SSubmitBlk* pBlock, SShellSubmitRspMsg *pRsp, tsem_t** pSem);
 
 static FORCE_INLINE int tsdbCheckRowRange(STsdbRepo *pRepo, STable *pTable, SMemRow row, TSKEY minKey, TSKEY maxKey,
                                           TSKEY now);
 
-int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp) {
+int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp, tsem_t** ppSem) {
   STsdbRepo *    pRepo = repo;
   SSubmitMsgIter msgIter = {0};
   SSubmitBlk *   pBlock = NULL;
   int32_t        affectedrows = 0, numOfRows = 0;
+  int32_t        ret = TSDB_CODE_SUCCESS;
 
   if (tsdbScanAndConvertSubmitMsg(pRepo, pMsg) < 0) {
     if (terrno != TSDB_CODE_TDB_TABLE_RECONFIGURE) {
@@ -70,8 +72,16 @@ int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pR
   while (true) {
     tsdbGetSubmitMsgNext(&msgIter, &pBlock);
     if (pBlock == NULL) break;
-    if (tsdbInsertDataToTable(pRepo, pBlock, &affectedrows) < 0) {
-      return -1;
+    if (IS_CONTROL_BLOCK(pBlock)) {
+      // COMMAND DATA BLOCK
+      ret = tsdbInsertControlData(pRepo, pBlock, pRsp, ppSem);
+      // all control msg is one SSubmitMsg, so need return
+      return ret; 
+    } else {
+      // INSERT DATA BLOCK
+      if (tsdbInsertDataToTable(pRepo, pBlock, &affectedrows) < 0) {
+        return -1;
+      }
     }
     numOfRows += pBlock->numOfRows;
   }
@@ -82,7 +92,7 @@ int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pR
   }
 
   if (tsdbCheckCommit(pRepo) < 0) return -1;
-  return 0;
+  return ret;
 }
 
 // ---------------- INTERNAL FUNCTIONS ----------------
@@ -290,7 +300,9 @@ int tsdbSyncCommitConfig(STsdbRepo* pRepo) {
   }
 
   if (tsdbLockRepo(pRepo) < 0) return -1;
-  tsdbScheduleCommit(pRepo, COMMIT_CONFIG_REQ);
+  if (tsdbScheduleCommit(pRepo, NULL, COMMIT_CONFIG_REQ) < 0) {
+    tsem_post(&(pRepo->readyToCommit));
+  }
   if (tsdbUnlockRepo(pRepo) < 0) return -1;
 
   tsem_wait(&(pRepo->readyToCommit));
@@ -305,11 +317,12 @@ int tsdbSyncCommitConfig(STsdbRepo* pRepo) {
   return 0;
 }
 
-int tsdbAsyncCommit(STsdbRepo *pRepo) {
+int tsdbAsyncCommit(STsdbRepo *pRepo, SControlDataInfo* pCtlDataInfo) {
   tsem_wait(&(pRepo->readyToCommit));
 
   ASSERT(pRepo->imem == NULL);
-  if (pRepo->mem == NULL) {
+
+  if (pRepo->mem == NULL && pCtlDataInfo == NULL) {
     tsem_post(&(pRepo->readyToCommit));
     return 0;
   }
@@ -320,9 +333,33 @@ int tsdbAsyncCommit(STsdbRepo *pRepo) {
 
   if (pRepo->appH.notifyStatus) pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_START, TSDB_CODE_SUCCESS);
   if (tsdbLockRepo(pRepo) < 0) return -1;
-  pRepo->imem = pRepo->mem;
-  pRepo->mem = NULL;
-  tsdbScheduleCommit(pRepo, COMMIT_REQ);
+  
+  bool post = false;
+  if (pRepo->mem) {
+    // has data in mem
+    pRepo->imem = pRepo->mem;
+    pRepo->mem = NULL;
+    if(pCtlDataInfo == NULL) {
+      if (tsdbScheduleCommit(pRepo, NULL, COMMIT_REQ) < 0)
+        post = true;
+    } else {
+      pCtlDataInfo->memNull = false; 
+      if(tsdbScheduleCommit(pRepo, pCtlDataInfo, COMMIT_BOTH_REQ) < 0)
+        post = true;
+    }
+  } else {
+    // no data in mem
+    if (pCtlDataInfo) {
+      pCtlDataInfo->memNull = true; 
+      if(tsdbScheduleCommit(pRepo, pCtlDataInfo, COMMIT_BOTH_REQ) < 0)
+        post = true;
+    }
+  }
+
+  // need post
+  if(post)
+    tsem_post(&(pRepo->readyToCommit));
+
   if (tsdbUnlockRepo(pRepo) < 0) return -1;
 
   return 0;
@@ -331,7 +368,7 @@ int tsdbAsyncCommit(STsdbRepo *pRepo) {
 int tsdbSyncCommit(STsdbRepo *repo) {
   STsdbRepo *pRepo = repo;
 
-  tsdbAsyncCommit(pRepo);
+  tsdbAsyncCommit(pRepo, NULL);
   tsem_wait(&(pRepo->readyToCommit));
   tsem_post(&(pRepo->readyToCommit));
 
@@ -669,6 +706,10 @@ static int tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg) {
     pBlock->numOfRows = htons(pBlock->numOfRows);
 
     if (pBlock->tid <= 0 || pBlock->tid >= pMeta->maxTables) {
+      if (IS_CONTROL_BLOCK(pBlock)) {
+        // super talbe control block tid == 0
+        continue;
+      }
       tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
                 pBlock->tid);
       terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
@@ -698,10 +739,13 @@ static int tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg) {
       }
     }
 
-    tsdbInitSubmitBlkIter(pBlock, &blkIter);
-    while ((row = tsdbGetSubmitBlkNext(&blkIter)) != NULL) {
-      if (tsdbCheckRowRange(pRepo, pTable, row, minKey, maxKey, now) < 0) {
-        return -1;
+    // check each row time invalid if not control block
+    if (!IS_CONTROL_BLOCK(pBlock)) {
+      tsdbInitSubmitBlkIter(pBlock, &blkIter);
+      while ((row = tsdbGetSubmitBlkNext(&blkIter)) != NULL) {
+        if (tsdbCheckRowRange(pRepo, pTable, row, minKey, maxKey, now) < 0) {
+          return -1;
+        }
       }
     }
   }
@@ -1078,3 +1122,112 @@ static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SMemRow r
 
   return 0;
 }
+
+// set tid to ptids and return all tables num 
+int32_t tsdbTableGroupInfo(STableGroupInfo* pTableGroup, int32_t * ptids) {
+  int32_t pos = 0;
+  size_t  numOfGroup = taosArrayGetSize(pTableGroup->pGroupList);
+  for (int32_t i = 0; i < numOfGroup; ++i) {
+    SArray* group = taosArrayGetP(pTableGroup->pGroupList, i);
+    size_t  cnt   = taosArrayGetSize(group);
+    for(int32_t j = 0; j < cnt; ++j) {
+      STableKeyInfo* pKeyInfo = (STableKeyInfo*) taosArrayGet(group, j);
+      if (pKeyInfo->pTable != NULL) {
+        if(ptids)
+          ptids[pos] = tsdbTableTid(pKeyInfo->pTable);
+        pos ++;
+      }
+    }
+  }
+  return pos;
+}
+
+// Control Data
+int32_t tsdbInsertControlData(STsdbRepo* pRepo, SSubmitBlk* pBlock, SShellSubmitRspMsg *pRsp, tsem_t** ppSem) {
+  int32_t ret = TSDB_CODE_SUCCESS;
+  SControlData* pCtlData = (SControlData* )pBlock->data;
+
+  // anti-serialize
+  pCtlData->command  = htonl(pCtlData->command);
+  pCtlData->win.skey = htobe64(pCtlData->win.skey);
+  pCtlData->win.ekey = htobe64(pCtlData->win.ekey);
+  pCtlData->tagCondLen = htonl(pCtlData->tagCondLen);
+
+  // get tables after filter tag condition
+  STableGroupInfo tableGroupInfo = {0};
+  tableGroupInfo.sVersion = -1;
+  tableGroupInfo.tVersion = -1;
+  
+  // get del tables tid
+  int32_t tnum;
+  if (pCtlData->command & FLAG_SUPER_TABLE) {
+    // super table
+    ret = tsdbQuerySTableByTagCond(pRepo, pBlock->uid, pCtlData->win.skey, pCtlData->tagCond, pCtlData->tagCondLen, &tableGroupInfo, NULL, 0);
+    if (ret != TSDB_CODE_SUCCESS) {
+      tsdbError(":SDEL vgId:%d failed to get child tables id from stable with tag condition. uid=%" PRIu64, REPO_ID(pRepo), pBlock->uid);
+      if(tableGroupInfo.pGroupList)
+        tsdbDestroyTableGroup(&tableGroupInfo);
+      return ret;
+    }
+
+    tnum = tsdbTableGroupInfo(&tableGroupInfo, NULL);
+    if (tnum == 0) {
+      tsdbWarn(":SDEL vgId:%d super table no child tables after filter by tag. uid=%" PRIu64, REPO_ID(pRepo), pBlock->uid);
+      if(tableGroupInfo.pGroupList)
+        tsdbDestroyTableGroup(&tableGroupInfo);
+      return TSDB_CODE_SUCCESS;
+    }
+  } else {
+    // single table
+    tnum = 1;
+  }
+
+  // if need response (pRsp not null) , malloc ppSem for async wait response
+  if (ppSem && pRsp) {
+    *ppSem = (tsem_t* )tmalloc(sizeof(tsem_t));
+    ret = tsem_init(*ppSem, 0, 0);
+    if(ret != 0) {
+      if(tableGroupInfo.pGroupList)
+        tsdbDestroyTableGroup(&tableGroupInfo);
+      return TAOS_SYSTEM_ERROR(ret);
+    }
+  }
+
+  // server data set 
+  size_t nsize = sizeof(SControlDataInfo) + tnum * sizeof(int32_t);
+  SControlDataInfo* pNew = (SControlDataInfo* )tmalloc(nsize);
+  memset(pNew, 0, nsize);
+  pNew->win     = pCtlData->win;
+  pNew->command = pCtlData->command;
+  pNew->pRsp    = pRsp;
+  if (ppSem)
+     pNew->pSem = *ppSem;
+  
+  // tids
+  pNew->tnum = tnum;
+  // copy tid
+  if (pCtlData->command & FLAG_SUPER_TABLE) {
+    tsdbTableGroupInfo(&tableGroupInfo, pNew->tids);
+  } else {
+    pNew->tids[0] = pBlock->tid;
+  }
+
+  if(pCtlData->command & CMD_DELETE_DATA) {
+    // malloc new to pass commit thread
+    ret = tsdbAsyncCommit(pRepo, pNew);
+  }
+
+  // if async post failed , must set wait event ppSem NULL
+  if(ret != TSDB_CODE_SUCCESS) {
+    if(*ppSem) {
+      tsem_destroy(*ppSem);
+      *ppSem = NULL;
+    }
+    tfree(pNew);
+  }
+  
+  if(tableGroupInfo.pGroupList)
+    tsdbDestroyTableGroup(&tableGroupInfo);
+
+  return ret;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 381320826e73e2a314234d7fd9244f827498b737..8fd22e44d23fe05b7790b644ef4dd852a82f30dc 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -639,7 +639,7 @@ static int32_t lazyLoadCacheLast(STsdbQueryHandle* pQueryHandle) {
       initTableMemIterator(pQueryHandle, pCheckInfo);
     }
 
-    code = tsdbLoadLastCache(pRepo, pTable);
+    code = tsdbLoadLastCache(pRepo, pTable, false);
     if (code != 0) {
       tsdbError("%p uid:%" PRId64 ", tid:%d, failed to load last cache since %s", pQueryHandle, pTable->tableId.uid,
                 pTable->tableId.tid, tstrerror(terrno));
@@ -4691,3 +4691,9 @@ void tsdbAddScanCallback(TsdbQueryHandleT* queryHandle, readover_callback callba
   pQueryHandle->param       = param;
   return ;
 }
+
+// get table tid
+int32_t tsdbTableTid(void* pTable) {
+  STable *p = (STable *)pTable;
+  return p->tableId.tid;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbReadImpl.c b/src/tsdb/src/tsdbReadImpl.c
index 57b91e5f3d867c79b3739bfe2f88e73239dd2eb6..10727ecf0f8101238ca2e63658d7963d29fac325 100644
--- a/src/tsdb/src/tsdbReadImpl.c
+++ b/src/tsdb/src/tsdbReadImpl.c
@@ -682,7 +682,6 @@ static int tsdbLoadBlockDataImpl(SReadH *pReadh, SBlock *pBlock, SDataCols *pDat
     uint32_t toffset = TSDB_KEY_COL_OFFSET;
     int32_t  tlen = pBlock->keyLen;
 
-
     if (dcol != 0) {
       tsdbGetSBlockCol(pBlock, &pBlockCol, pBlockData->cols, ccol);
       tcolId = pBlockCol->colId;
diff --git a/src/tsdb/tests/tsdbTests.cpp b/src/tsdb/tests/tsdbTests.cpp
index dc804856fdf1e288f2a70a2813639c1324f42851..a7e5a5b3509cabaa64f78b17e82dcf8b2c9a4166 100644
--- a/src/tsdb/tests/tsdbTests.cpp
+++ b/src/tsdb/tests/tsdbTests.cpp
@@ -74,12 +74,12 @@ static int insertData(SInsertInfo *pInfo) {
     pBlock->tid = htonl(pBlock->tid);
 
     pBlock->sversion = htonl(pBlock->sversion);
-    pBlock->padding = htonl(pBlock->padding);
+    pBlock->flag = htonl(pBlock->flag);
 
     pMsg->length = htonl(pMsg->length);
     pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
 
-    if (tsdbInsertData(pInfo->pRepo, pMsg, NULL) < 0) {
+    if (tsdbInsertData(pInfo->pRepo, pMsg, NULL, NULL) < 0) {
       tfree(pMsg);
       return -1;
     }
diff --git a/src/util/src/terror.c b/src/util/src/terror.c
index cee9245ec79abce96d8990e179cfd457791bf318..334207022d61fdcf80f26fe626edcb7de9628944 100644
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
@@ -256,6 +256,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_VND_NOT_SYNCED,               "Database suspended")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            "Database write operation denied")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_SYNCING,               "Database is syncing")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_INVALID_TSDB_STATE,       "Invalid tsdb state")
+TAOS_DEFINE_ERROR(TSDB_CODE_WAIT_THREAD_TOO_MANY,         "Wait threads too many")
 
 // tsdb
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_ID,         "Invalid table ID")
diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c
index 2a17e4ae52f86314d7d1340e95ba56f586f89b97..d97e3b79909d6ea9a2ca4baec9ff86018415e012 100644
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
@@ -228,7 +228,8 @@ static SKeyword keywordTable[] = {
     {"RANGE",        TK_RANGE},
     {"CONTAINS",     TK_CONTAINS},
     {"TO",           TK_TO},
-    {"SPLIT",        TK_SPLIT}   
+    {"SPLIT",        TK_SPLIT},
+    {"DELETE",       TK_DELETE}
 };
 
 static const char isIdChar[] = {
diff --git a/src/vnode/inc/vnodeInt.h b/src/vnode/inc/vnodeInt.h
index 1deceebb0ad3bd146a3cd81fab4cabb2d290b037..bc18ccddcd789b15c9b6ea91f5a639d6d7ade0ad 100644
--- a/src/vnode/inc/vnodeInt.h
+++ b/src/vnode/inc/vnodeInt.h
@@ -75,6 +75,9 @@ typedef struct {
   tsem_t   sem;
   char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
   pthread_mutex_t statusMutex;
+  // thread for wait deal result to response client
+  SList *  waitThreads;
+  tsem_t   semWait;
 } SVnodeObj;
 
 #ifdef __cplusplus
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index c823880ae2028c4bcfe26dbfc5cd60af62443722..81ab56ccea1a585ae7bf89a57244edd25818c0d5 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -29,6 +29,9 @@
 #include "vnodeWorker.h"
 #include "vnodeBackup.h"
 #include "vnodeMain.h"
+#include "tqueue.h"
+#include "tthread.h"
+#include "tcrc32c.h"
 
 static int32_t vnodeProcessTsdbStatus(void *arg, int32_t status, int32_t eno);
 
@@ -117,7 +120,7 @@ int32_t vnodeDrop(int32_t vgId) {
 int32_t vnodeCompact(int32_t vgId) {
   void *pVnode = vnodeAcquire(vgId);
   if (pVnode != NULL) {
-    vDebug("vgId:%d, compact vnode msg is received", vgId);
+    vDebug("vgId:%d, compact vnode msg is received\n", vgId);
     //not care success or not
     tsdbCompact(((SVnodeObj*)pVnode)->tsdb);  
     vnodeRelease(pVnode);
@@ -271,6 +274,9 @@ int32_t vnodeOpen(int32_t vgId) {
   tsem_init(&pVnode->sem, 0, 0);
   pthread_mutex_init(&pVnode->statusMutex, NULL);
   vnodeSetInitStatus(pVnode);
+  // wait thread init
+  tsem_init(&pVnode->semWait, 0, 1);
+  pVnode->waitThreads = tdListNew(sizeof(SWaitThread));  
 
   tsdbIncCommitRef(pVnode->vgId);
 
@@ -418,6 +424,62 @@ int32_t vnodeOpen(int32_t vgId) {
   return TSDB_CODE_SUCCESS;
 }
 
+#define LOOP_CNT 10
+void vnodeStopWaitingThread(SVnodeObj* pVnode) {
+  // check wait thread empty
+  SWaitThread* pWaitThread = NULL;
+  vDebug("vgId:%d :SDEL stop waiting thread count=%d", pVnode->vgId, listNEles(pVnode->waitThreads));
+  if(listNEles(pVnode->waitThreads) == 0) {
+    return;
+  }
+  vInfo("vgId:%d :SDEL stop waiting thread not zero. count=%d", pVnode->vgId, listNEles(pVnode->waitThreads));
+
+  // get lock
+  tsem_wait(&pVnode->semWait);
+
+  // loop stop
+  while (1) {
+    SListNode * pNode = tdListPopHead(pVnode->waitThreads);
+    if(pNode == NULL)
+      break;
+
+    // thread is running    
+    pWaitThread = (SWaitThread *)pNode->data;
+    int32_t loop = LOOP_CNT;
+    while (taosThreadRunning(pWaitThread->pthread)) {
+      vInfo("vgId:%d :SDEL loop=%d thread runing post to quit. pthread=%p", pVnode->vgId, loop, pWaitThread->pthread);
+      // only post once
+      if(loop == LOOP_CNT) 
+        tsem_post(pWaitThread->psem);
+      taosMsleep(50);
+      loop -= 1; 
+      if(loop == 0 )
+        break;
+    }
+
+    // free all
+    if(loop == 0) {
+      vInfo("vgId:%d :SDEL force kill thread to quit. pthread=%p pWrite=%p", pVnode->vgId, pWaitThread->pthread, pWaitThread->param);
+      // thread not stop , so need kill
+      taosDestoryThread(pWaitThread->pthread);
+      // write msg need remove from queue
+      SVWriteMsg* pWrite = (SVWriteMsg* )pWaitThread->param;
+      if (pWrite)
+        vnodeFreeFromWQueue(pWrite->pVnode, pWrite);
+    } else {
+      vInfo("vgId:%d :SDEL quit thread ok. pthread=%p pWrite=%p", pVnode->vgId, pWaitThread->pthread, pWaitThread->param);
+      free(pWaitThread->pthread);
+    }
+    tsem_destroy(pWaitThread->psem);
+    
+    // free node
+    free(pNode);
+  }
+
+  // unlock
+  tsem_post(&pVnode->semWait);  
+}
+
 int32_t vnodeClose(int32_t vgId) {
   SVnodeObj *pVnode = vnodeAcquireNotClose(vgId);
   if (pVnode == NULL) return 0;
@@ -438,7 +500,10 @@ int32_t vnodeClose(int32_t vgId) {
 void vnodeDestroy(SVnodeObj *pVnode) {
   int32_t code = 0;
   int32_t vgId = pVnode->vgId;
-  
+
+    // stop wait thread if have
+  vnodeStopWaitingThread(pVnode);
+
   if (pVnode->qMgmt) {
     qCleanupQueryMgmt(pVnode->qMgmt);
     pVnode->qMgmt = NULL;
@@ -504,6 +569,8 @@ void vnodeDestroy(SVnodeObj *pVnode) {
     dnodeSendStatusMsgToMnode();
   }
 
+  pVnode->waitThreads = tdListFree(pVnode->waitThreads);
+  tsem_destroy(&pVnode->semWait);  
   tsem_destroy(&pVnode->sem);
   pthread_mutex_destroy(&pVnode->statusMutex);
   free(pVnode);
@@ -567,3 +634,62 @@ static int32_t vnodeProcessTsdbStatus(void *arg, int32_t status, int32_t eno) {
 
   return 0;
 }
+
+// wait thread
+void vnodeAddWait(void* vparam, pthread_t* pthread, tsem_t* psem, void* param) {
+  SVnodeObj*   pVnode      = (SVnodeObj* )vparam;
+  SWaitThread waitThread = {0};
+
+  waitThread.pthread     = pthread;
+  waitThread.startTime   = taosGetTimestampSec();
+  waitThread.psem        = psem;
+  waitThread.param       = param;
+
+  // append
+  tdListAppend(pVnode->waitThreads, &waitThread);
+  vDebug("vgId:%d :SDEL add wait thread %p wait list count=%d ", pVnode->vgId, param, listNEles(pVnode->waitThreads));
+}
+
+// called in wait thread
+void vnodeRemoveWait(void* vparam, void* param) {
+    SVnodeObj* pVnode = (SVnodeObj* )vparam;
+    SListIter iter = {0};
+
+    tsem_wait(&pVnode->semWait);
+    tdListInitIter(pVnode->waitThreads, &iter, TD_LIST_FORWARD);
+
+    while (1) {
+      SListNode* pNode = tdListNext(&iter);
+      if (pNode == NULL)
+        break;
+
+      SWaitThread * pWaitThread = (SWaitThread *)pNode->data;
+      if (pWaitThread->param == param) {
+        // found , free SWaitThread memeber
+        free(pWaitThread->pthread);
+        tdListPopNode(pVnode->waitThreads, pNode);
+        vDebug("vgId:%d :SDEL removed wait thread %p wait list count=%d ", pVnode->vgId, param, listNEles(pVnode->waitThreads));
+        // free pListNode self
+        free(pNode);
+        break;
+      }
+    }
+    tsem_post(&pVnode->semWait);
+}
+
+// get wait thread count
+bool vnodeWaitTooMany(void* vparam) {
+  SVnodeObj* pVnode = (SVnodeObj* )vparam;
+  int32_t count = listNEles(pVnode->waitThreads);
+  if( count > 32 ) {
+    vError("vgId:%d :SDEL wait threads too many. count=%d", pVnode->vgId, count);
+    return true;
+  }
+
+  return false;
+}
+
+tsem_t* vnodeSemWait(void* vparam) {
+  SVnodeObj* pVnode = (SVnodeObj* )vparam;
+  return &pVnode->semWait;
+}
\ No newline at end of file
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index 8d2487168fa36a744af7e4aed01cb09447822036..e3371c79db76f4a3875b505aa7f56c67969c49ce 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -63,6 +63,10 @@ int32_t vnodeProcessWrite(void *vparam, void *wparam, int32_t qtype, void *rpara
 
   SRspRet *pRspRet = NULL;
   if (pWrite != NULL) pRspRet = &pWrite->rspRet;
+  // if wal and forward write , no need response
+  if( qtype == TAOS_QTYPE_WAL || qtype == TAOS_QTYPE_FWD) {
+    pRspRet = NULL;
+  }   
 
   if (vnodeProcessWriteMsgFp[pHead->msgType] == NULL) {
     vError("vgId:%d, msg:%s not processed since no handle, qtype:%s hver:%" PRIu64, pVnode->vgId,
@@ -107,7 +111,7 @@ int32_t vnodeProcessWrite(void *vparam, void *wparam, int32_t qtype, void *rpara
     code = walWrite(pVnode->wal, pHead);
   }
   if (code < 0) {
-    if (syncCode > 0) atomic_sub_fetch_32(&pWrite->processedCount, 1);
+    if (syncCode > 0 && pWrite) atomic_sub_fetch_32(&pWrite->processedCount, 1);
     vError("vgId:%d, hver:%" PRIu64 " vver:%" PRIu64 " code:0x%x", pVnode->vgId, pHead->version, pVnode->version, code);
     pHead->version = 0;
     return code;
@@ -118,7 +122,7 @@ int32_t vnodeProcessWrite(void *vparam, void *wparam, int32_t qtype, void *rpara
   // write data locally
   code = (*vnodeProcessWriteMsgFp[pHead->msgType])(pVnode, pHead->cont, pRspRet);
   if (code < 0) {
-    if (syncCode > 0) atomic_sub_fetch_32(&pWrite->processedCount, 1);
+    if (syncCode > 0 && pWrite) atomic_sub_fetch_32(&pWrite->processedCount, 1);
     return code;
   }
 
@@ -163,13 +167,15 @@ static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pR
 
   // save insert result into item
   SShellSubmitRspMsg *pRsp = NULL;
+  tsem_t** ppsem = NULL;
   if (pRet) {
     pRet->len = sizeof(SShellSubmitRspMsg);
     pRet->rsp = rpcMallocCont(pRet->len);
     pRsp = pRet->rsp;
+    ppsem = &pRet->psem;
   }
 
-  if (tsdbInsertData(pVnode->tsdb, pCont, pRsp) < 0) {
+  if (tsdbInsertData(pVnode->tsdb, pCont, pRsp, ppsem) < 0) {
     code = terrno;
   } else {
     if (pRsp != NULL) atomic_fetch_add_64(&tsSubmitReqSucNum, 1);
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index b6f367c5ef5989add11015d69a5f0cb3afa9e730..3e6901a7156f2e660f91f64a4e59552e6daaf778 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -189,9 +189,12 @@ python3 test.py -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanosub
 python3 test.py -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestInsertTime_step.py
 python3 test.py -f tools/taosdumpTestNanoSupport.py
 
-#
+# tsdb
+python3 ./test.py -f tsdb/insert.py
 # python3 ./test.py -f tsdb/tsdbComp.py
 
+
+
 # update
 python3 ./test.py -f update/allow_update.py
 python3 ./test.py -f update/allow_update-0.py
diff --git a/tests/pytest/tsdb/delete.py b/tests/pytest/tsdb/delete.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cfd910c46e1591b21c50b55af31a0113c4cd7bb
--- /dev/null
+++ b/tests/pytest/tsdb/delete.py
@@ -0,0 +1,285 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+
+from numpy.lib.function_base import insert
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+
+# constant define
+WAITS = 10 # wait seconds
+
+class TDTestCase:
+    #
+    # --------------- main frame -------------------
+    #
+    
+    def caseDescription(self):
+        '''
+        limit and offset keyword function test cases;
+        case1: limit offset base function test
+        case2: limit offset advance test
+        '''
+        return 
+
+    # init
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        tdSql.prepare()
+        self.create_tables()
+        self.ts = 1500000000000
+
+
+    # run case  
+    def run(self):
+        # insert data
+        for i in range(10):
+          tbname = "t%d"%i
+          self.insert_data(tbname, self.ts, (i+1)*10000, 20000);
+
+        tdLog.debug(" INSERT data 10 tables ....... [OK]")  
+
+        # test base case
+        self.test_case1()
+        tdLog.debug(" DELETE test_case1 ............ [OK]")
+        # test advance case
+        self.test_case2()
+        tdLog.debug(" DELETE test_case2 ............ [OK]")
+
+
+    # stop 
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+    #
+    # --------------- case  -------------------
+    #
+
+    # create table
+    def create_tables(self):
+        # super table
+        tdSql.execute("create table st(ts timestamp, i1 int) tags(area int)")
+        # child table
+        for i in range(10):
+          sql = "create table t%d using st tags(%d)"%(i, i)
+          tdSql.execute(sql)
+        
+        return 
+
+    # insert data1
+    def insert_data(self, tbname, ts_start, count, batch_num):
+        pre_insert = "insert into %s values"%tbname
+        sql = pre_insert
+        tdLog.debug("doing insert table %s rows=%d ..."%(tbname, count))
+        for i in range(count):
+            sql += " (%d,%d)"%(ts_start + i*1000, i)
+            if i >0 and i%batch_num == 0:
+                tdSql.execute(sql)
+                sql = pre_insert
+        # end sql        
+        if sql != pre_insert:
+            tdSql.execute(sql)
+
+        return
+
+    # test case1 base 
+    def test_case1(self):
+        # 
+        # delete from single table
+        #
+        
+        # where <
+        sql = "select count(*) from t0 where ts < 1500000120000"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 120)
+        
+        sql = "delete from t0 where ts < 1500000120000"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(120)
+
+        sql = "select count(*) from t0"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 10000 - 120 )
+
+        sql = "select * from t0 limit 1"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 120)
+
+        # where > and <
+        sql = "delete from t0 where ts > 1500000240000 and ts <= 1500000300000"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(60)
+        sql = "select count(*) from t0"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 10000 - 120 - 60)
+
+        sql = "select * from t0 limit 2 offset 120"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 240)
+        tdSql.checkData(1, 1, 301)
+
+        
+        # where >  delete 1000 rows from end
+        sql = "delete from t0 where ts >= 1500009000000; "
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(1000)
+        sql = "select count(*) from t0"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 10000 - 120 - 60 - 1000)
+        
+        sql = "select last_row(*) from t0; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 8999)
+
+        sql = "select last(*) from t0"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 8999)
+
+        # insert last_row
+        sql = "insert into t0 values(1500009999000,9999); "
+        tdSql.execute(sql)
+
+        sql = "select last_row(*) from t0; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 9999)
+
+        sql = "select last(*) from t0"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 9999)
+
+        # insert last 
+        sql = "insert into t0 values(1500010000000,10000); "
+        tdSql.execute(sql)
+        sql = "insert into t0 values(1500010002000,NULL); "
+        tdSql.execute(sql)
+        sql = "insert into t0 values(1500010001000,10001); "
+        tdSql.execute(sql)
+        sql = "delete from t0 where ts = 1500010001000;  "
+        tdSql.execute(sql)
+
+        sql = "select last_row(i1) from t0; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, None)
+
+        sql = "select last(i1) from t0; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 10000)
+
+        # delete whole
+        sql = "delete from t0;"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(8823)
+        
+        return 
+
+    # test advance 
+    def test_case2(self):
+        # 
+        # delete from super table
+        #
+        
+        # where <
+        sql = "select count(*) from st where ts < 1500000120000;"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 9*120) #1080
+        
+        sql = "delete from st where ts < 1500000120000;"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(9*120) #1080
+
+        sql = "select count(*) from st;"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 540000 - 9*120 )
+
+        sql = "select * from st limit 1;"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 120)
+
+        # where > and <
+        sql = "delete from st where ts > 1500000240000 and ts <= 1500000300000;"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(9*60)
+        sql = "select count(*) from st;"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 540000 - 9*120 - 9*60)
+
+        sql = "select * from st limit 2 offset 120"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 240)
+        tdSql.checkData(1, 1, 301)
+
+        
+        # where >  delete 1000 rows from end
+        sql = "delete from st where ts >= 1500009000000; "
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(459000)
+        sql = "select count(*) from st;"
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 79380)
+        
+        sql = "select last_row(*) from st; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 8999)
+
+        sql = "select last(*) from st"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 8999)
+
+        # insert last_row
+        sql = "insert into t0 values(1500009999000,9999); "
+        tdSql.execute(sql)
+
+        sql = "select last_row(*) from st; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 9999)
+
+        sql = "select last(*) from st"
+        tdSql.query(sql)
+        tdSql.checkData(0, 1, 9999)
+
+        # insert last 
+        sql = "insert into t0 values(1500010000000,10000); "
+        tdSql.execute(sql)
+        sql = "insert into t0 values(1500010002000,NULL); "
+        tdSql.execute(sql)
+        sql = "insert into t0 values(1500010001000,10001); "
+        tdSql.execute(sql)
+        sql = "delete from t0 where ts = 1500010001000;  "
+        tdSql.execute(sql)
+
+        sql = "select last_row(i1) from st; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, None)
+
+        sql = "select last(i1) from st; "
+        tdSql.query(sql)
+        tdSql.checkData(0, 0, 10000)
+
+        # delete whole
+        sql = "delete from st;"
+        tdSql.execute(sql)
+        tdSql.checkAffectedRows(79383)
+        
+        return 
+
+#
+# add case with filename
+#
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file