Merge pull request #13467 from taosdata/feature/3.0_wxy

feat: sql command 'delete from'

include/common/ttokendef.h

@@ -193,65 +193,66 @@
 #define TK_REDISTRIBUTE  175
 #define TK_SPLIT         176
 #define TK_SYNCDB        177
-#define TK_NULL          178
-#define TK_NK_QUESTION   179
-#define TK_NK_ARROW      180
-#define TK_ROWTS         181
-#define TK_TBNAME        182
-#define TK_QSTARTTS      183
-#define TK_QENDTS        184
-#define TK_WSTARTTS      185
-#define TK_WENDTS        186
-#define TK_WDURATION     187
-#define TK_CAST          188
-#define TK_NOW           189
-#define TK_TODAY         190
-#define TK_TIMEZONE      191
-#define TK_COUNT         192
-#define TK_FIRST         193
-#define TK_LAST          194
-#define TK_LAST_ROW      195
-#define TK_BETWEEN       196
-#define TK_IS            197
-#define TK_NK_LT         198
-#define TK_NK_GT         199
-#define TK_NK_LE         200
-#define TK_NK_GE         201
-#define TK_NK_NE         202
-#define TK_MATCH         203
-#define TK_NMATCH        204
-#define TK_CONTAINS      205
-#define TK_JOIN          206
-#define TK_INNER         207
-#define TK_SELECT        208
-#define TK_DISTINCT      209
-#define TK_WHERE         210
-#define TK_PARTITION     211
-#define TK_BY            212
-#define TK_SESSION       213
-#define TK_STATE_WINDOW  214
-#define TK_SLIDING       215
-#define TK_FILL          216
-#define TK_VALUE         217
-#define TK_NONE          218
-#define TK_PREV          219
-#define TK_LINEAR        220
-#define TK_NEXT          221
-#define TK_HAVING        222
-#define TK_ORDER         223
-#define TK_SLIMIT        224
-#define TK_SOFFSET       225
-#define TK_LIMIT         226
-#define TK_OFFSET        227
-#define TK_ASC           228
-#define TK_NULLS         229
-#define TK_ID            230
-#define TK_NK_BITNOT     231
-#define TK_INSERT        232
-#define TK_VALUES        233
-#define TK_IMPORT        234
-#define TK_NK_SEMI       235
-#define TK_FILE          236
+#define TK_DELETE        178
+#define TK_NULL          179
+#define TK_NK_QUESTION   180
+#define TK_NK_ARROW      181
+#define TK_ROWTS         182
+#define TK_TBNAME        183
+#define TK_QSTARTTS      184
+#define TK_QENDTS        185
+#define TK_WSTARTTS      186
+#define TK_WENDTS        187
+#define TK_WDURATION     188
+#define TK_CAST          189
+#define TK_NOW           190
+#define TK_TODAY         191
+#define TK_TIMEZONE      192
+#define TK_COUNT         193
+#define TK_FIRST         194
+#define TK_LAST          195
+#define TK_LAST_ROW      196
+#define TK_BETWEEN       197
+#define TK_IS            198
+#define TK_NK_LT         199
+#define TK_NK_GT         200
+#define TK_NK_LE         201
+#define TK_NK_GE         202
+#define TK_NK_NE         203
+#define TK_MATCH         204
+#define TK_NMATCH        205
+#define TK_CONTAINS      206
+#define TK_JOIN          207
+#define TK_INNER         208
+#define TK_SELECT        209
+#define TK_DISTINCT      210
+#define TK_WHERE         211
+#define TK_PARTITION     212
+#define TK_BY            213
+#define TK_SESSION       214
+#define TK_STATE_WINDOW  215
+#define TK_SLIDING       216
+#define TK_FILL          217
+#define TK_VALUE         218
+#define TK_NONE          219
+#define TK_PREV          220
+#define TK_LINEAR        221
+#define TK_NEXT          222
+#define TK_HAVING        223
+#define TK_ORDER         224
+#define TK_SLIMIT        225
+#define TK_SOFFSET       226
+#define TK_LIMIT         227
+#define TK_OFFSET        228
+#define TK_ASC           229
+#define TK_NULLS         230
+#define TK_ID            231
+#define TK_NK_BITNOT     232
+#define TK_INSERT        233
+#define TK_VALUES        234
+#define TK_IMPORT        235
+#define TK_NK_SEMI       236
+#define TK_FILE          237
 
 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301

include/libs/nodes/nodes.h

@@ -180,6 +180,7 @@ typedef enum ENodeType {
   QUERY_NODE_KILL_CONNECTION_STMT,
   QUERY_NODE_KILL_QUERY_STMT,
   QUERY_NODE_KILL_TRANSACTION_STMT,
+  QUERY_NODE_DELETE_STMT,
   QUERY_NODE_QUERY,
 
   // logic plan node

include/libs/nodes/querynodes.h

@@ -60,6 +60,7 @@ typedef struct SColumnNode {
   int8_t      tableType;
   col_id_t    colId;
   EColumnType colType;  // column or tag
+  bool        hasIndex;
   char        dbName[TSDB_DB_NAME_LEN];
   char        tableName[TSDB_TABLE_NAME_LEN];
   char        tableAlias[TSDB_TABLE_NAME_LEN];
@@ -258,6 +259,7 @@ typedef struct SSetOperator {
   SNodeList*       pOrderByList;  // SOrderByExprNode
   SNode*           pLimit;
   char             stmtName[TSDB_TABLE_NAME_LEN];
+  uint8_t          precision;
 } SSetOperator;
 
 typedef enum ESqlClause {
@@ -272,6 +274,17 @@ typedef enum ESqlClause {
   SQL_CLAUSE_ORDER_BY
 } ESqlClause;
 
+typedef struct SDeleteStmt {
+  ENodeType   type;           // QUERY_NODE_DELETE_STMT
+  SNode*      pFromTable;     // FROM clause
+  SNode*      pWhere;         // WHERE clause
+  SNode*      pCountFunc;     // count the number of rows affected
+  SNode*      pTagIndexCond;  // pWhere divided into pTagIndexCond and timeRange
+  STimeWindow timeRange;
+  uint8_t     precision;
+  bool        deleteZeroRows;
+} SDeleteStmt;
+
 typedef enum {
   PAYLOAD_TYPE_KV = 0,
   PAYLOAD_TYPE_RAW = 1,
@@ -363,8 +376,11 @@ bool nodesIsRegularOp(const SOperatorNode* pOp);
 void*   nodesGetValueFromNode(SValueNode* pNode);
 int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value);
 char*   nodesGetStrValueFromNode(SValueNode* pNode);
-char*   getFillModeString(EFillMode mode);
-void    valueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
+void    nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
+
+char*   nodesGetFillModeString(EFillMode mode);
+int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);
+int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond);
 
 #ifdef __cplusplus
 }

include/util/taoserror.h

@@ -649,6 +649,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_COL_JSON          TAOS_DEF_ERROR_CODE(0, 0x2652)
 #define TSDB_CODE_PAR_VALUE_TOO_LONG            TAOS_DEF_ERROR_CODE(0, 0x2653)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2654)
+#define TSDB_CODE_PAR_INVALID_DELETE_WHERE      TAOS_DEF_ERROR_CODE(0, 0x2655)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)

source/libs/executor/src/executorimpl.c

@@ -345,7 +345,6 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR
     // In case of group by column query, the required SResultRow object must be existInCurrentResusltRowInfo in the
     // pResultRowInfo object.
     if (p1 != NULL) {
-
       // todo
       pResult = getResultRowByPos(pResultBuf, p1);
       ASSERT(pResult->pageId == p1->pageId && pResult->offset == p1->offset);
@@ -356,7 +355,7 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR
   if (pResultRowInfo->cur.pageId != -1 && ((pResult == NULL) || (pResult->pageId != pResultRowInfo->cur.pageId &&
                                                                  pResult->offset != pResultRowInfo->cur.offset))) {
     SResultRowPosition pos = pResultRowInfo->cur;
-    SFilePage* pPage = getBufPage(pResultBuf, pos.pageId);
+    SFilePage*         pPage = getBufPage(pResultBuf, pos.pageId);
     releaseBufPage(pResultBuf, pPage);
   }
 
@@ -369,7 +368,8 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR
 
     // add a new result set for a new group
     SResultRowPosition pos = {.pageId = pResult->pageId, .offset = pResult->offset};
-    taosHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, sizeof(SResultRowPosition));
+    taosHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos,
+                sizeof(SResultRowPosition));
   }
 
   // 2. set the new time window to be the new active time window
@@ -551,7 +551,6 @@ void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow
   colDataAppendInt64(pColData, 4, &pQueryWindow->ekey);
 }
 
-
 void doApplyFunctions(SExecTaskInfo* taskInfo, SqlFunctionCtx* pCtx, STimeWindow* pWin,
                       SColumnInfoData* pTimeWindowData, int32_t offset, int32_t forwardStep, TSKEY* tsCol,
                       int32_t numOfTotal, int32_t numOfOutput, int32_t order) {
@@ -1219,9 +1218,9 @@ void setTaskKilled(SExecTaskInfo* pTaskInfo) { pTaskInfo->code = TSDB_CODE_TSC_Q
 static bool isCachedLastQuery(STaskAttr* pQueryAttr) {
   for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
     int32_t functionId = getExprFunctionId(&pQueryAttr->pExpr1[i]);
-//    if (functionId == FUNCTION_LAST || functionId == FUNCTION_LAST_DST) {
-//      continue;
-//    }
+    //    if (functionId == FUNCTION_LAST || functionId == FUNCTION_LAST_DST) {
+    //      continue;
+    //    }
 
     return false;
   }
@@ -1283,7 +1282,6 @@ static int32_t updateBlockLoadStatus(STaskAttr* pQuery, int32_t status) {
       hasOtherFunc = true;
     }
 #endif
-
   }
 
   if (hasFirstLastFunc && status == BLK_DATA_NOT_LOAD) {
@@ -1765,7 +1763,6 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t* bufCapacity, int32_t numOf
       //      if (i > 0) pBInfo->pCtx[i].pTsOutput = pBInfo->pCtx[i - 1].pOutput;
     }
 #endif
-
   }
 }
 
@@ -4262,7 +4259,7 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
       pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale,
                                              pType->precision, pValNode->node.aliasName);
       pExp->base.pParam[0].type = FUNC_PARAM_TYPE_VALUE;
-      valueNodeToVariant(pValNode, &pExp->base.pParam[0].param);
+      nodesValueNodeToVariant(pValNode, &pExp->base.pParam[0].param);
     } else if (type == QUERY_NODE_FUNCTION) {
       pExp->pExpr->nodeType = QUERY_NODE_FUNCTION;
       SFunctionNode* pFuncNode = (SFunctionNode*)pTargetNode->pExpr;
@@ -4305,7 +4302,7 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
         } else if (p1->type == QUERY_NODE_VALUE) {
           SValueNode* pvn = (SValueNode*)p1;
           pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
-          valueNodeToVariant(pvn, &pExp->base.pParam[j].param);
+          nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
         }
       }
     } else if (type == QUERY_NODE_OPERATOR) {
@@ -4392,7 +4389,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       }
       SArray* groupKyes = extractPartitionColInfo(pTableScanNode->pPartitionKeys);
       extractTableSchemaVersion(pHandle, pTableScanNode->scan.uid, pTaskInfo);
-      SOperatorInfo* pOperator = createTableScanOperatorInfo(pTableScanNode, pDataReader, pHandle, groupKyes, pTaskInfo);
+      SOperatorInfo* pOperator =
+          createTableScanOperatorInfo(pTableScanNode, pDataReader, pHandle, groupKyes, pTaskInfo);
 
       STableScanInfo* pScanInfo = pOperator->info;
       pTaskInfo->cost.pRecoder = &pScanInfo->readRecorder;
@@ -4420,10 +4418,10 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       } else {
         qDebug("%s pDataReader is not NULL", GET_TASKID(pTaskInfo));
       }
-      SArray*        tableIdList = extractTableIdList(pTableListInfo);
+      SArray* tableIdList = extractTableIdList(pTableListInfo);
 
-      SOperatorInfo* pOperator = createStreamScanOperatorInfo(pDataReader, pHandle,
-          tableIdList, pTableScanNode, pTaskInfo, &twSup);
+      SOperatorInfo* pOperator =
+          createStreamScanOperatorInfo(pDataReader, pHandle, tableIdList, pTableScanNode, pTaskInfo, &twSup);
 
       taosArrayDestroy(tableIdList);
       return pOperator;
@@ -4522,18 +4520,19 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
                           .offset = pIntervalPhyNode->offset,
                           .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
 
-    STimeWindowAggSupp as = {.waterMark = pIntervalPhyNode->window.watermark,
-                             .calTrigger = pIntervalPhyNode->window.triggerType,
-                             .maxTs = INT64_MIN,
-                             .winMap = NULL,};
+    STimeWindowAggSupp as = {
+        .waterMark = pIntervalPhyNode->window.watermark,
+        .calTrigger = pIntervalPhyNode->window.triggerType,
+        .maxTs = INT64_MIN,
+        .winMap = NULL,
+    };
     if (isSmaStream(pIntervalPhyNode->window.triggerType)) {
       if (FLT_LESS(pIntervalPhyNode->window.filesFactor, 1.000000)) {
         as.calTrigger = STREAM_TRIGGER_AT_ONCE_SMA;
       } else {
         _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);
         as.winMap = taosHashInit(64, hashFn, true, HASH_NO_LOCK);
-        as.waterMark = getSmaWaterMark(interval.interval,
-            pIntervalPhyNode->window.filesFactor);
+        as.waterMark = getSmaWaterMark(interval.interval, pIntervalPhyNode->window.filesFactor);
         as.calTrigger = STREAM_TRIGGER_WINDOW_CLOSE_SMA;
       }
     }
@@ -5208,14 +5207,13 @@ int32_t initStreamAggSupporter(SStreamAggSupporter* pSup, const char* pKey) {
 
 int64_t getSmaWaterMark(int64_t interval, double filesFactor) {
   int64_t waterMark = 0;
-  ASSERT(FLT_GREATEREQUAL(filesFactor,0.000000));
+  ASSERT(FLT_GREATEREQUAL(filesFactor, 0.000000));
   waterMark = -1 * filesFactor;
   return waterMark;
 }
 
 bool isSmaStream(int8_t triggerType) {
-  if (triggerType == STREAM_TRIGGER_AT_ONCE ||
-      triggerType == STREAM_TRIGGER_WINDOW_CLOSE) {
+  if (triggerType == STREAM_TRIGGER_AT_ONCE || triggerType == STREAM_TRIGGER_WINDOW_CLOSE) {
     return false;
   }
   return true;

source/libs/index/src/indexFilter.c

@@ -31,7 +31,7 @@ typedef struct SIFParam {
   SHashObj *pFilter;
 
   SArray *result;
-  char *  condValue;
+  char   *condValue;
 
   SIdxFltStatus status;
   uint8_t       colValType;
@@ -45,7 +45,7 @@ typedef struct SIFParam {
 
 typedef struct SIFCtx {
   int32_t       code;
-  SHashObj *    pRes;    /* element is SIFParam */
+  SHashObj     *pRes;    /* element is SIFParam */
   bool          noExec;  // true: just iterate condition tree, and add hint to executor plan
   SIndexMetaArg arg;
   // SIdxFltStatus st;
@@ -128,7 +128,7 @@ static int32_t sifGetValueFromNode(SNode *node, char **value) {
   // covert data From snode;
   SValueNode *vn = (SValueNode *)node;
 
-  char *     pData = nodesGetValueFromNode(vn);
+  char      *pData = nodesGetValueFromNode(vn);
   SDataType *pType = &vn->node.resType;
   int32_t    type = pType->type;
   int32_t    valLen = 0;
@@ -486,7 +486,7 @@ static int32_t sifExecLogic(SLogicConditionNode *node, SIFCtx *ctx, SIFParam *ou
     return TSDB_CODE_QRY_INVALID_INPUT;
   }
 
-  int32_t   code;
+  int32_t   code = TSDB_CODE_SUCCESS;
   SIFParam *params = NULL;
   SIF_ERR_RET(sifInitParamList(&params, node->pParameterList, ctx));
 
@@ -664,7 +664,7 @@ int32_t doFilterTag(const SNode *pFilterNode, SIndexMetaArg *metaArg, SArray *re
   // todo move to the initialization function
   // SIF_ERR_RET(filterInitFromNode((SNode *)pFilterNode, &filter, 0));
 
-  SArray * output = taosArrayInit(8, sizeof(uint64_t));
+  SArray  *output = taosArrayInit(8, sizeof(uint64_t));
   SIFParam param = {.arg = *metaArg, .result = output};
   SIF_ERR_RET(sifCalculate((SNode *)pFilterNode, &param));
 

source/libs/nodes/src/nodesCloneFuncs.c

@@ -98,6 +98,7 @@ static SNode* columnNodeCopy(const SColumnNode* pSrc, SColumnNode* pDst) {
   COPY_SCALAR_FIELD(tableType);
   COPY_SCALAR_FIELD(colId);
   COPY_SCALAR_FIELD(colType);
+  COPY_SCALAR_FIELD(hasIndex);
   COPY_CHAR_ARRAY_FIELD(dbName);
   COPY_CHAR_ARRAY_FIELD(tableName);
   COPY_CHAR_ARRAY_FIELD(tableAlias);

source/libs/nodes/src/nodesCodeFuncs.c

@@ -178,6 +178,8 @@ const char* nodesNodeName(ENodeType type) {
       return "ShowQueriesStmt";
     case QUERY_NODE_SHOW_VNODES_STMT:
       return "ShowVnodeStmt";
+    case QUERY_NODE_DELETE_STMT:
+      return "DeleteStmt";
     case QUERY_NODE_LOGIC_PLAN_SCAN:
       return "LogicScan";
     case QUERY_NODE_LOGIC_PLAN_JOIN:

source/libs/nodes/src/nodesUtilFuncs.c

@@ -208,6 +208,8 @@ SNodeptr nodesMakeNode(ENodeType type) {
     case QUERY_NODE_KILL_QUERY_STMT:
     case QUERY_NODE_KILL_TRANSACTION_STMT:
       return makeNode(type, sizeof(SKillStmt));
+    case QUERY_NODE_DELETE_STMT:
+      return makeNode(type, sizeof(SDeleteStmt));
     case QUERY_NODE_LOGIC_PLAN_SCAN:
       return makeNode(type, sizeof(SScanLogicNode));
     case QUERY_NODE_LOGIC_PLAN_JOIN:
@@ -1305,7 +1307,7 @@ int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeT
   return TSDB_CODE_SUCCESS;
 }
 
-char* getFillModeString(EFillMode mode) {
+char* nodesGetFillModeString(EFillMode mode) {
   switch (mode) {
     case FILL_MODE_NONE:
       return "none";
@@ -1353,7 +1355,7 @@ int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {
   return num;
 }
 
-void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
+void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
   pVal->nType = pNode->node.resType.type;
   pVal->nLen = pNode->node.resType.bytes;
   switch (pNode->node.resType.type) {
@@ -1394,3 +1396,159 @@ void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
       break;
   }
 }
+
+int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) {
+  if (NULL == *pSrc) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (1 == LIST_LENGTH(*pSrc)) {
+    *pDst = nodesListGetNode(*pSrc, 0);
+    nodesClearList(*pSrc);
+  } else {
+    SLogicConditionNode* pLogicCond = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
+    if (NULL == pLogicCond) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
+    pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
+    pLogicCond->condType = LOGIC_COND_TYPE_AND;
+    pLogicCond->pParameterList = *pSrc;
+    *pDst = (SNode*)pLogicCond;
+  }
+  *pSrc = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+typedef struct SClassifyConditionCxt {
+  bool hasPrimaryKey;
+  bool hasTagIndexCol;
+  bool hasOtherCol;
+} SClassifyConditionCxt;
+
+static EDealRes classifyConditionImpl(SNode* pNode, void* pContext) {
+  SClassifyConditionCxt* pCxt = (SClassifyConditionCxt*)pContext;
+  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
+    SColumnNode* pCol = (SColumnNode*)pNode;
+    if (PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId) {
+      pCxt->hasPrimaryKey = true;
+    } else if (pCol->hasIndex) {
+      pCxt->hasTagIndexCol = true;
+    } else {
+      pCxt->hasOtherCol = true;
+    }
+    return *((bool*)pContext) ? DEAL_RES_CONTINUE : DEAL_RES_END;
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+typedef enum EConditionType { COND_TYPE_PRIMARY_KEY = 1, COND_TYPE_TAG_INDEX, COND_TYPE_NORMAL } EConditionType;
+
+static EConditionType classifyCondition(SNode* pNode) {
+  SClassifyConditionCxt cxt = {.hasPrimaryKey = false, .hasTagIndexCol = false, .hasOtherCol = false};
+  nodesWalkExpr(pNode, classifyConditionImpl, &cxt);
+  return cxt.hasOtherCol ? COND_TYPE_NORMAL
+                         : (cxt.hasPrimaryKey && cxt.hasTagIndexCol
+                                ? COND_TYPE_NORMAL
+                                : (cxt.hasPrimaryKey ? COND_TYPE_PRIMARY_KEY : COND_TYPE_TAG_INDEX));
+}
+
+static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond) {
+  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(*pCondition);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SNodeList* pPrimaryKeyConds = NULL;
+  SNodeList* pTagConds = NULL;
+  SNodeList* pOtherConds = NULL;
+  SNode*     pCond = NULL;
+  FOREACH(pCond, pLogicCond->pParameterList) {
+    switch (classifyCondition(pCond)) {
+      case COND_TYPE_PRIMARY_KEY:
+        if (NULL != pPrimaryKeyCond) {
+          code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond));
+        }
+        break;
+      case COND_TYPE_TAG_INDEX:
+        if (NULL != pTagCond) {
+          code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
+        }
+        break;
+      case COND_TYPE_NORMAL:
+      default:
+        if (NULL != pOtherCond) {
+          code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
+        }
+        break;
+    }
+    if (TSDB_CODE_SUCCESS != code) {
+      break;
+    }
+  }
+
+  SNode* pTempPrimaryKeyCond = NULL;
+  SNode* pTempTagCond = NULL;
+  SNode* pTempOtherCond = NULL;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempTagCond, &pTagConds);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempOtherCond, &pOtherConds);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    if (NULL != pPrimaryKeyCond) {
+      *pPrimaryKeyCond = pTempPrimaryKeyCond;
+    }
+    if (NULL != pTagCond) {
+      *pTagCond = pTempTagCond;
+    }
+    if (NULL != pOtherCond) {
+      *pOtherCond = pTempOtherCond;
+    }
+    nodesDestroyNode(*pCondition);
+    *pCondition = NULL;
+  } else {
+    nodesDestroyList(pPrimaryKeyConds);
+    nodesDestroyList(pTagConds);
+    nodesDestroyList(pOtherConds);
+    nodesDestroyNode(pTempPrimaryKeyCond);
+    nodesDestroyNode(pTempTagCond);
+    nodesDestroyNode(pTempOtherCond);
+  }
+
+  return code;
+}
+
+int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond) {
+  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCondition) &&
+      LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCondition)->condType) {
+    return partitionLogicCond(pCondition, pPrimaryKeyCond, pTagCond, pOtherCond);
+  }
+
+  switch (classifyCondition(*pCondition)) {
+    case COND_TYPE_PRIMARY_KEY:
+      if (NULL != pPrimaryKeyCond) {
+        *pPrimaryKeyCond = *pCondition;
+      }
+      break;
+    case COND_TYPE_TAG_INDEX:
+      if (NULL != pTagCond) {
+        *pTagCond = *pCondition;
+      }
+      break;
+    case COND_TYPE_NORMAL:
+    default:
+      if (NULL != pOtherCond) {
+        *pOtherCond = *pCondition;
+      }
+      break;
+  }
+  *pCondition = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}

source/libs/parser/inc/parAst.h

@@ -193,6 +193,7 @@ SNode* createSplitVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId);
 SNode* createSyncdbStmt(SAstCreateContext* pCxt, const SToken* pDbName);
 SNode* createGrantStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDbName, SToken* pUserName);
 SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDbName, SToken* pUserName);
+SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere);
 
 #ifdef __cplusplus
 }

source/libs/parser/inc/sql.y

@@ -481,6 +481,9 @@ dnode_list(A) ::= dnode_list(B) DNODE NK_INTEGER(C).
 /************************************************ syncdb **************************************************************/
 cmd ::= SYNCDB db_name(A) REPLICA.                                                { pCxt->pRootNode = createSyncdbStmt(pCxt, &A); }
 
+/************************************************ syncdb **************************************************************/
+cmd ::= DELETE FROM full_table_name(A) where_clause_opt(B).                       { pCxt->pRootNode = createDeleteStmt(pCxt, A, B); }
+
 /************************************************ select **************************************************************/
 cmd ::= query_expression(A).                                                      { pCxt->pRootNode = A; }
 

source/libs/parser/src/parAstCreater.c

@@ -1488,3 +1488,12 @@ SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDb
   strncpy(pStmt->userName, pUserName->z, pUserName->n);
   return (SNode*)pStmt;
 }
+
+SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere) {
+  CHECK_PARSER_STATUS(pCxt);
+  SDeleteStmt* pStmt = nodesMakeNode(QUERY_NODE_DELETE_STMT);
+  CHECK_OUT_OF_MEM(pStmt);
+  pStmt->pFromTable = pTable;
+  pStmt->pWhere = pWhere;
+  return (SNode*)pStmt;
+}

source/libs/parser/src/parAstParser.c

@@ -113,21 +113,26 @@ static EDealRes collectMetaKeyFromFunction(SCollectMetaKeyFromExprCxt* pCxt, SFu
   return reserveUdfInCache(pFunc->functionName, pCxt->pComCxt->pMetaCache);
 }
 
-static EDealRes collectMetaKeyFromRealTable(SCollectMetaKeyFromExprCxt* pCxt, SRealTableNode* pRealTable) {
-  pCxt->errCode = reserveTableMetaInCache(pCxt->pComCxt->pParseCxt->acctId, pRealTable->table.dbName,
-                                          pRealTable->table.tableName, pCxt->pComCxt->pMetaCache);
-  if (TSDB_CODE_SUCCESS == pCxt->errCode) {
-    pCxt->errCode = reserveTableVgroupInCache(pCxt->pComCxt->pParseCxt->acctId, pRealTable->table.dbName,
-                                              pRealTable->table.tableName, pCxt->pComCxt->pMetaCache);
+static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, SRealTableNode* pRealTable,
+                                               AUTH_TYPE authType) {
+  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pRealTable->table.tableName,
+                                         pCxt->pMetaCache);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pRealTable->table.tableName,
+                                     pCxt->pMetaCache);
   }
-  if (TSDB_CODE_SUCCESS == pCxt->errCode) {
-    pCxt->errCode = reserveUserAuthInCache(pCxt->pComCxt->pParseCxt->acctId, pCxt->pComCxt->pParseCxt->pUser,
-                                           pRealTable->table.dbName, AUTH_TYPE_READ, pCxt->pComCxt->pMetaCache);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pRealTable->table.dbName, authType,
+                                  pCxt->pMetaCache);
   }
-  if (TSDB_CODE_SUCCESS == pCxt->errCode) {
-    pCxt->errCode =
-        reserveDbVgInfoInCache(pCxt->pComCxt->pParseCxt->acctId, pRealTable->table.dbName, pCxt->pComCxt->pMetaCache);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pCxt->pMetaCache);
   }
+  return code;
+}
+
+static EDealRes collectMetaKeyFromRealTable(SCollectMetaKeyFromExprCxt* pCxt, SRealTableNode* pRealTable) {
+  pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, pRealTable, AUTH_TYPE_READ);
   return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR;
 }
 
@@ -347,6 +352,10 @@ static int32_t collectMetaKeyFromShowTransactions(SCollectMetaKeyCxt* pCxt, SSho
                                  pCxt->pMetaCache);
 }
 
+static int32_t collectMetaKeyFromDelete(SCollectMetaKeyCxt* pCxt, SDeleteStmt* pStmt) {
+  return collectMetaKeyFromRealTableImpl(pCxt, (SRealTableNode*)pStmt->pFromTable, AUTH_TYPE_WRITE);
+}
+
 static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) {
   switch (nodeType(pStmt)) {
     case QUERY_NODE_SET_OPERATOR:
@@ -405,6 +414,8 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) {
       return collectMetaKeyFromShowTopics(pCxt, (SShowStmt*)pStmt);
     case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
       return collectMetaKeyFromShowTransactions(pCxt, (SShowStmt*)pStmt);
+    case QUERY_NODE_DELETE_STMT:
+      return collectMetaKeyFromDelete(pCxt, (SDeleteStmt*)pStmt);
     default:
       break;
   }

source/libs/parser/src/parAuthenticator.c

@@ -80,6 +80,10 @@ static int32_t authDropUser(SAuthCxt* pCxt, SDropUserStmt* pStmt) {
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t authDelete(SAuthCxt* pCxt, SDeleteStmt* pDelete) {
+  return checkAuth(pCxt, ((SRealTableNode*)pDelete->pFromTable)->table.dbName, AUTH_TYPE_WRITE);
+}
+
 static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
   switch (nodeType(pStmt)) {
     case QUERY_NODE_SET_OPERATOR:
@@ -88,6 +92,8 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) {
       return authSelect(pCxt, (SSelectStmt*)pStmt);
     case QUERY_NODE_DROP_USER_STMT:
       return authDropUser(pCxt, (SDropUserStmt*)pStmt);
+    case QUERY_NODE_DELETE_STMT:
+      return authDelete(pCxt, (SDeleteStmt*)pStmt);
     default:
       break;
   }

source/libs/parser/src/parCalcConst.c

@@ -135,11 +135,11 @@ static int32_t rewriteConditionForFromTable(SCalcConstContext* pCxt, SNode* pTab
   return code;
 }
 
-static int32_t calcConstFromTable(SCalcConstContext* pCxt, SSelectStmt* pSelect) {
-  return rewriteConditionForFromTable(pCxt, pSelect->pFromTable);
+static int32_t calcConstFromTable(SCalcConstContext* pCxt, SNode* pTable) {
+  return rewriteConditionForFromTable(pCxt, pTable);
 }
 
-static void rewriteConstCondition(SSelectStmt* pSelect, SNode** pCond) {
+static void rewriteConstCondition(SNode** pCond, bool* pAlwaysFalse) {
   if (QUERY_NODE_VALUE != nodeType(*pCond)) {
     return;
   }
@@ -147,11 +147,11 @@ static void rewriteConstCondition(SSelectStmt* pSelect, SNode** pCond) {
     nodesDestroyNode(*pCond);
     *pCond = NULL;
   } else {
-    pSelect->isEmptyResult = true;
+    *pAlwaysFalse = true;
   }
 }
 
-static int32_t calcConstSelectCondition(SCalcConstContext* pCxt, SSelectStmt* pSelect, SNode** pCond) {
+static int32_t calcConstStmtCondition(SCalcConstContext* pCxt, SNode** pCond, bool* pAlwaysFalse) {
   if (NULL == *pCond) {
     return TSDB_CODE_SUCCESS;
   }
@@ -161,7 +161,7 @@ static int32_t calcConstSelectCondition(SCalcConstContext* pCxt, SSelectStmt* pS
     code = calcConstNode(pCond);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    rewriteConstCondition(pSelect, pCond);
+    rewriteConstCondition(pCond, pAlwaysFalse);
   }
   return code;
 }
@@ -233,12 +233,12 @@ static int32_t calcConstGroupBy(SCalcConstContext* pCxt, SSelectStmt* pSelect) {
 }
 
 static int32_t calcConstSelect(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {
-  int32_t code = calcConstFromTable(pCxt, pSelect);
+  int32_t code = calcConstFromTable(pCxt, pSelect->pFromTable);
   if (TSDB_CODE_SUCCESS == code) {
     code = calcConstProjections(pCxt, pSelect, subquery);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = calcConstSelectCondition(pCxt, pSelect, &pSelect->pWhere);
+    code = calcConstStmtCondition(pCxt, &pSelect->pWhere, &pSelect->isEmptyResult);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = calcConstList(pSelect->pPartitionByList);
@@ -250,7 +250,7 @@ static int32_t calcConstSelect(SCalcConstContext* pCxt, SSelectStmt* pSelect, bo
     code = calcConstGroupBy(pCxt, pSelect);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = calcConstSelectCondition(pCxt, pSelect, &pSelect->pHaving);
+    code = calcConstStmtCondition(pCxt, &pSelect->pHaving, &pSelect->isEmptyResult);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = calcConstList(pSelect->pOrderByList);
@@ -258,6 +258,14 @@ static int32_t calcConstSelect(SCalcConstContext* pCxt, SSelectStmt* pSelect, bo
   return code;
 }
 
+static int32_t calcConstDelete(SCalcConstContext* pCxt, SDeleteStmt* pDelete) {
+  int32_t code = calcConstFromTable(pCxt, pDelete->pFromTable);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = calcConstStmtCondition(pCxt, &pDelete->pWhere, &pDelete->deleteZeroRows);
+  }
+  return code;
+}
+
 static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pStmt)) {
@@ -275,6 +283,9 @@ static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subque
       }
       break;
     }
+    case QUERY_NODE_DELETE_STMT:
+      code = calcConstDelete(pCxt, (SDeleteStmt*)pStmt);
+      break;
     default:
       break;
   }

source/libs/parser/src/parTokenizer.c

@@ -68,6 +68,7 @@ static SKeyword keywordTable[] = {
     {"DATABASES",     TK_DATABASES},
     {"DAYS",          TK_DAYS},
     {"DBS",           TK_DBS},
+    {"DELETE",        TK_DELETE},
     {"DESC",          TK_DESC},
     {"DESCRIBE",      TK_DESCRIBE},
     {"DISTINCT",      TK_DISTINCT},

source/libs/parser/src/parUtil.c

@@ -178,6 +178,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Only tag can be json type";
     case TSDB_CODE_PAR_VALUE_TOO_LONG:
       return "Value too long for column/tag: %s";
+    case TSDB_CODE_PAR_INVALID_DELETE_WHERE:
+      return "The DELETE statement must have a definite time window range";
     case TSDB_CODE_OUT_OF_MEMORY:
       return "Out of memory";
     default:
@@ -322,11 +324,11 @@ static bool isValidateTag(char* input) {
   return true;
 }
 
-int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag **ppTag, SMsgBuf* pMsgBuf) {
+int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, SMsgBuf* pMsgBuf) {
   int32_t   retCode = TSDB_CODE_SUCCESS;
-  cJSON* root = NULL;
+  cJSON*    root = NULL;
   SHashObj* keyHash = NULL;
-  int32_t size = 0;
+  int32_t   size = 0;
   // set json NULL data
   if (!json || strtrim((char*)json) == 0 || strcasecmp(json, TSDB_DATA_NULL_STR_L) == 0) {
     retCode = TSDB_CODE_SUCCESS;
@@ -371,7 +373,8 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag **ppTag, SMs
     }
     STagVal val = {0};
     val.pKey = jsonKey;
-    taosHashPut(keyHash, jsonKey, keyLen, &keyLen, CHAR_BYTES);  // add key to hash to remove dumplicate, value is useless
+    taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
+                CHAR_BYTES);  // add key to hash to remove dumplicate, value is useless
 
     if (item->type == cJSON_String) {  // add json value  format: type|data
       char*   jsonValue = item->valuestring;
@@ -382,8 +385,7 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag **ppTag, SMs
         goto end;
       }
       val.type = TSDB_DATA_TYPE_NCHAR;
-      if (valLen > 0 && !taosMbsToUcs4(jsonValue, valLen, (TdUcs4*)tmp,
-                                       (int32_t)(valLen * TSDB_NCHAR_SIZE), &valLen)) {
+      if (valLen > 0 && !taosMbsToUcs4(jsonValue, valLen, (TdUcs4*)tmp, (int32_t)(valLen * TSDB_NCHAR_SIZE), &valLen)) {
         uError("charset:%s to %s. val:%s, errno:%s, convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, jsonValue,
                strerror(errno));
         retCode = buildSyntaxErrMsg(pMsgBuf, "charset convert json error", jsonValue);
@@ -413,7 +415,7 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag **ppTag, SMs
 
 end:
   taosHashCleanup(keyHash);
-  if(retCode == TSDB_CODE_SUCCESS){
+  if (retCode == TSDB_CODE_SUCCESS) {
     tTagNew(pTagVals, 1, true, ppTag);
   }
   cJSON_Delete(root);

source/libs/parser/test/parInitialDTest.cpp

@@ -21,7 +21,21 @@ namespace ParserTest {
 
 class ParserInitialDTest : public ParserDdlTest {};
 
-// todo delete
+// DELETE FROM tb_name [WHERE condition]
+TEST_F(ParserInitialDTest, delete) {
+  useDb("root", "test");
+
+  run("DELETE FROM t1");
+
+  run("DELETE FROM t1 WHERE ts > now - 2d and ts < now - 1d");
+}
+
+TEST_F(ParserInitialDTest, deleteSemanticCheck) {
+  useDb("root", "test");
+
+  run("DELETE FROM t1 WHERE c1 > 10", TSDB_CODE_PAR_INVALID_DELETE_WHERE, PARSER_STAGE_TRANSLATE);
+}
+
 // todo desc
 // todo describe
 // todo DROP account

source/libs/parser/test/parSelectTest.cpp

@@ -229,14 +229,14 @@ TEST_F(ParserSelectTest, subquery) {
   run("SELECT SUM(a) FROM (SELECT MAX(c1) a, _wstartts FROM st1s1 PARTITION BY TBNAME INTERVAL(1m)) INTERVAL(1n)");
 }
 
-TEST_F(ParserSelectTest, subquerySemanticError) {
+TEST_F(ParserSelectTest, subquerySemanticCheck) {
   useDb("root", "test");
 
   run("SELECT SUM(a) FROM (SELECT MAX(c1) a FROM st1s1 INTERVAL(1m)) INTERVAL(1n)", TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY,
       PARSER_STAGE_TRANSLATE);
 }
 
-TEST_F(ParserSelectTest, semanticError) {
+TEST_F(ParserSelectTest, semanticCheck) {
   useDb("root", "test");
 
   // TSDB_CODE_PAR_INVALID_COLUMN

source/libs/planner/src/planLogicCreater.c

@@ -21,8 +21,10 @@ typedef struct SLogicPlanContext {
   SPlanContext* pPlanCxt;
 } SLogicPlanContext;
 
-typedef int32_t (*FCreateLogicNode)(SLogicPlanContext*, SSelectStmt*, SLogicNode**);
+typedef int32_t (*FCreateLogicNode)(SLogicPlanContext*, void*, SLogicNode**);
+typedef int32_t (*FCreateSelectLogicNode)(SLogicPlanContext*, SSelectStmt*, SLogicNode**);
 typedef int32_t (*FCreateSetOpLogicNode)(SLogicPlanContext*, SSetOperator*, SLogicNode**);
+typedef int32_t (*FCreateDeleteLogicNode)(SLogicPlanContext*, SDeleteStmt*, SLogicNode**);
 
 static int32_t doCreateLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SNode* pTable,
                                         SLogicNode** pLogicNode);
@@ -119,12 +121,12 @@ static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLo
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t createChildLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, FCreateLogicNode func,
-                                    SLogicNode** pRoot) {
+static int32_t createRootLogicNode(SLogicPlanContext* pCxt, void* pStmt, uint8_t precision, FCreateLogicNode func,
+                                   SLogicNode** pRoot) {
   SLogicNode* pNode = NULL;
-  int32_t     code = func(pCxt, pSelect, &pNode);
+  int32_t     code = func(pCxt, pStmt, &pNode);
   if (TSDB_CODE_SUCCESS == code && NULL != pNode) {
-    pNode->precision = pSelect->precision;
+    pNode->precision = precision;
     code = pushLogicNode(pCxt, pRoot, pNode);
   }
   if (TSDB_CODE_SUCCESS != code) {
@@ -133,56 +135,10 @@ static int32_t createChildLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelec
   return code;
 }
 
-// typedef struct SCreateColumnCxt {
-//   int32_t    errCode;
-//   SNodeList* pList;
-// } SCreateColumnCxt;
-
-// static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
-//   SCreateColumnCxt* pCxt = (SCreateColumnCxt*)pContext;
-//   switch (nodeType(pNode)) {
-//     case QUERY_NODE_COLUMN: {
-//       SNode* pCol = nodesCloneNode(pNode);
-//       if (NULL == pCol) {
-//         return DEAL_RES_ERROR;
-//       }
-//       return (TSDB_CODE_SUCCESS == nodesListAppend(pCxt->pList, pCol) ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
-//     }
-//     case QUERY_NODE_OPERATOR:
-//     case QUERY_NODE_LOGIC_CONDITION:
-//     case QUERY_NODE_FUNCTION: {
-//       SExprNode*   pExpr = (SExprNode*)pNode;
-//       SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
-//       if (NULL == pCol) {
-//         return DEAL_RES_ERROR;
-//       }
-//       pCol->node.resType = pExpr->resType;
-//       strcpy(pCol->colName, pExpr->aliasName);
-//       return (TSDB_CODE_SUCCESS == nodesListAppend(pCxt->pList, pCol) ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
-//     }
-//     default:
-//       break;
-//   }
-
-//   return DEAL_RES_CONTINUE;
-// }
-
-// static int32_t createColumnByRewriteExps(SNodeList* pExprs, SNodeList** pList) {
-//   SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)};
-//   if (NULL == cxt.pList) {
-//     return TSDB_CODE_OUT_OF_MEMORY;
-//   }
-
-//   nodesWalkExprs(pExprs, doCreateColumn, &cxt);
-//   if (TSDB_CODE_SUCCESS != cxt.errCode) {
-//     nodesDestroyList(cxt.pList);
-//     return cxt.errCode;
-//   }
-//   if (NULL == *pList) {
-//     *pList = cxt.pList;
-//   }
-//   return cxt.errCode;
-// }
+static int32_t createSelectRootLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, FCreateSelectLogicNode func,
+                                         SLogicNode** pRoot) {
+  return createRootLogicNode(pCxt, pSelect, pSelect->precision, (FCreateLogicNode)func, pRoot);
+}
 
 static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols, SNodeList* pScanCols,
                              STableMeta* pMeta) {
@@ -783,25 +739,25 @@ static int32_t createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSele
   SLogicNode* pRoot = NULL;
   int32_t     code = createLogicNodeByTable(pCxt, pSelect, pSelect->pFromTable, &pRoot);
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createPartitionLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createPartitionLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createWindowLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createWindowLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createFillLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createFillLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createAggLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createAggLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createDistinctLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createDistinctLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createSortLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createSortLogicNode, &pRoot);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = createChildLogicNode(pCxt, pSelect, createProjectLogicNode, &pRoot);
+    code = createSelectRootLogicNode(pCxt, pSelect, createProjectLogicNode, &pRoot);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -813,17 +769,9 @@ static int32_t createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSele
   return code;
 }
 
-static int32_t createSetOpChildLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator,
-                                         FCreateSetOpLogicNode func, SLogicNode** pRoot) {
-  SLogicNode* pNode = NULL;
-  int32_t     code = func(pCxt, pSetOperator, &pNode);
-  if (TSDB_CODE_SUCCESS == code && NULL != pNode) {
-    code = pushLogicNode(pCxt, pRoot, pNode);
-  }
-  if (TSDB_CODE_SUCCESS != code) {
-    nodesDestroyNode(pNode);
-  }
-  return code;
+static int32_t createSetOpRootLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, FCreateSetOpLogicNode func,
+                                        SLogicNode** pRoot) {
+  return createRootLogicNode(pCxt, pSetOperator, pSetOperator->precision, (FCreateLogicNode)func, pRoot);
 }
 
 static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
@@ -970,7 +918,7 @@ static int32_t createSetOperatorLogicNode(SLogicPlanContext* pCxt, SSetOperator*
   SLogicNode* pRoot = NULL;
   int32_t     code = createSetOpLogicNode(pCxt, pSetOperator, &pRoot);
   if (TSDB_CODE_SUCCESS == code) {
-    code = createSetOpChildLogicNode(pCxt, pSetOperator, createSetOpSortLogicNode, &pRoot);
+    code = createSetOpRootLogicNode(pCxt, pSetOperator, createSetOpSortLogicNode, &pRoot);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -1008,6 +956,43 @@ static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifOpS
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t createDeleteRootLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, FCreateDeleteLogicNode func,
+                                         SLogicNode** pRoot) {
+  return createRootLogicNode(pCxt, pDelete, pDelete->precision, (FCreateLogicNode)func, pRoot);
+}
+
+static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
+  return TSDB_CODE_FAILED;
+}
+
+static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
+  return TSDB_CODE_FAILED;
+}
+
+static int32_t createDeleteModifyTableLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete,
+                                                SLogicNode** pLogicNode) {
+  return TSDB_CODE_FAILED;
+}
+
+static int32_t createDeleteLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
+  SLogicNode* pRoot = NULL;
+  int32_t     code = createDeleteRootLogicNode(pCxt, pDelete, createDeleteScanLogicNode, &pRoot);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createDeleteRootLogicNode(pCxt, pDelete, createDeleteAggLogicNode, &pRoot);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createDeleteRootLogicNode(pCxt, pDelete, createDeleteModifyTableLogicNode, &pRoot);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = pRoot;
+  } else {
+    nodesDestroyNode(pRoot);
+  }
+
+  return code;
+}
+
 static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogicNode** pLogicNode) {
   switch (nodeType(pStmt)) {
     case QUERY_NODE_SELECT_STMT:
@@ -1018,6 +1003,8 @@ static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogi
       return createQueryLogicNode(pCxt, ((SExplainStmt*)pStmt)->pQuery, pLogicNode);
     case QUERY_NODE_SET_OPERATOR:
       return createSetOperatorLogicNode(pCxt, (SSetOperator*)pStmt, pLogicNode);
+    case QUERY_NODE_DELETE_STMT:
+      return createDeleteLogicNode(pCxt, (SDeleteStmt*)pStmt, pLogicNode);
     default:
       break;
   }

source/libs/planner/src/planOptimizer.c

@@ -268,30 +268,6 @@ static int32_t cpdMergeCond(SNode** pDst, SNode** pSrc) {
   return code;
 }
 
-static int32_t cpdMergeConds(SNode** pDst, SNodeList** pSrc) {
-  if (NULL == *pSrc) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (1 == LIST_LENGTH(*pSrc)) {
-    *pDst = nodesListGetNode(*pSrc, 0);
-    nodesClearList(*pSrc);
-  } else {
-    SLogicConditionNode* pLogicCond = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
-    if (NULL == pLogicCond) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-    pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
-    pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
-    pLogicCond->condType = LOGIC_COND_TYPE_AND;
-    pLogicCond->pParameterList = *pSrc;
-    *pDst = (SNode*)pLogicCond;
-  }
-  *pSrc = NULL;
-
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t cpdCondAppend(SNode** pCond, SNode** pAdditionalCond) {
   if (NULL == *pCond) {
     TSWAP(*pCond, *pAdditionalCond);
@@ -310,119 +286,6 @@ static int32_t cpdCondAppend(SNode** pCond, SNode** pAdditionalCond) {
   return code;
 }
 
-static EDealRes cpdIsPrimaryKeyCondImpl(SNode* pNode, void* pContext) {
-  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
-    *((bool*)pContext) = ((PRIMARYKEY_TIMESTAMP_COL_ID == ((SColumnNode*)pNode)->colId) ? true : false);
-    return *((bool*)pContext) ? DEAL_RES_CONTINUE : DEAL_RES_END;
-  }
-  return DEAL_RES_CONTINUE;
-}
-
-static bool cpdIsPrimaryKeyCond(SNode* pNode) {
-  if (QUERY_NODE_LOGIC_CONDITION == nodeType(pNode)) {
-    return false;
-  }
-  bool isPrimaryKeyCond = false;
-  nodesWalkExpr(pNode, cpdIsPrimaryKeyCondImpl, &isPrimaryKeyCond);
-  return isPrimaryKeyCond;
-}
-
-static EDealRes cpdIsTagCondImpl(SNode* pNode, void* pContext) {
-  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
-    *((bool*)pContext) = ((COLUMN_TYPE_TAG == ((SColumnNode*)pNode)->colType) ? true : false);
-    return *((bool*)pContext) ? DEAL_RES_CONTINUE : DEAL_RES_END;
-  }
-  return DEAL_RES_CONTINUE;
-}
-
-static bool cpdIsTagCond(SNode* pNode) {
-  if (QUERY_NODE_LOGIC_CONDITION == nodeType(pNode)) {
-    return false;
-  }
-  bool isTagCond = false;
-  nodesWalkExpr(pNode, cpdIsTagCondImpl, &isTagCond);
-  return isTagCond;
-}
-
-static int32_t cpdPartitionScanLogicCond(SScanLogicNode* pScan, SNode** pPrimaryKeyCond, SNode** pTagCond,
-                                         SNode** pOtherCond) {
-  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)pScan->node.pConditions;
-
-  if (LOGIC_COND_TYPE_AND != pLogicCond->condType) {
-    *pPrimaryKeyCond = NULL;
-    *pOtherCond = pScan->node.pConditions;
-    pScan->node.pConditions = NULL;
-    return TSDB_CODE_SUCCESS;
-  }
-
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  SNodeList* pPrimaryKeyConds = NULL;
-  SNodeList* pTagConds = NULL;
-  SNodeList* pOtherConds = NULL;
-  SNode*     pCond = NULL;
-  FOREACH(pCond, pLogicCond->pParameterList) {
-    if (cpdIsPrimaryKeyCond(pCond)) {
-      code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond));
-    } else if (cpdIsTagCond(pScan->node.pConditions)) {
-      code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
-    } else {
-      code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
-    }
-    if (TSDB_CODE_SUCCESS != code) {
-      break;
-    }
-  }
-
-  SNode* pTempPrimaryKeyCond = NULL;
-  SNode* pTempTagCond = NULL;
-  SNode* pTempOtherCond = NULL;
-  if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempTagCond, &pTagConds);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempOtherCond, &pOtherConds);
-  }
-
-  if (TSDB_CODE_SUCCESS == code) {
-    *pPrimaryKeyCond = pTempPrimaryKeyCond;
-    *pTagCond = pTempTagCond;
-    *pOtherCond = pTempOtherCond;
-    nodesDestroyNode(pScan->node.pConditions);
-    pScan->node.pConditions = NULL;
-  } else {
-    nodesDestroyList(pPrimaryKeyConds);
-    nodesDestroyList(pTagConds);
-    nodesDestroyList(pOtherConds);
-    nodesDestroyNode(pTempPrimaryKeyCond);
-    nodesDestroyNode(pTempTagCond);
-    nodesDestroyNode(pTempOtherCond);
-  }
-
-  return code;
-}
-
-static int32_t cpdPartitionScanCond(SScanLogicNode* pScan, SNode** pPrimaryKeyCond, SNode** pTagCond,
-                                    SNode** pOtherCond) {
-  if (QUERY_NODE_LOGIC_CONDITION == nodeType(pScan->node.pConditions)) {
-    return cpdPartitionScanLogicCond(pScan, pPrimaryKeyCond, pTagCond, pOtherCond);
-  }
-
-  if (cpdIsPrimaryKeyCond(pScan->node.pConditions)) {
-    *pPrimaryKeyCond = pScan->node.pConditions;
-  } else if (cpdIsTagCond(pScan->node.pConditions)) {
-    *pTagCond = pScan->node.pConditions;
-  } else {
-    *pOtherCond = pScan->node.pConditions;
-  }
-  pScan->node.pConditions = NULL;
-
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t cpdCalcTimeRange(SScanLogicNode* pScan, SNode** pPrimaryKeyCond, SNode** pOtherCond) {
   bool    isStrict = false;
   int32_t code = filterGetTimeRange(*pPrimaryKeyCond, &pScan->scanRange, &isStrict);
@@ -472,7 +335,7 @@ static int32_t cpdOptimizeScanCondition(SOptimizeContext* pCxt, SScanLogicNode*
   SNode*  pPrimaryKeyCond = NULL;
   SNode*  pTagCond = NULL;
   SNode*  pOtherCond = NULL;
-  int32_t code = cpdPartitionScanCond(pScan, &pPrimaryKeyCond, &pTagCond, &pOtherCond);
+  int32_t code = nodesPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pTagCond, &pOtherCond);
   if (TSDB_CODE_SUCCESS == code && NULL != pPrimaryKeyCond) {
     code = cpdCalcTimeRange(pScan, &pPrimaryKeyCond, &pOtherCond);
   }
@@ -565,16 +428,16 @@ static int32_t cpdPartitionLogicCond(SJoinLogicNode* pJoin, SNode** pOnCond, SNo
   SNode* pTempRightChildCond = NULL;
   SNode* pTempRemainCond = NULL;
   if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempOnCond, &pOnConds);
+    code = nodesMergeConds(&pTempOnCond, &pOnConds);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempLeftChildCond, &pLeftChildConds);
+    code = nodesMergeConds(&pTempLeftChildCond, &pLeftChildConds);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempRightChildCond, &pRightChildConds);
+    code = nodesMergeConds(&pTempRightChildCond, &pRightChildConds);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = cpdMergeConds(&pTempRemainCond, &pRemainConds);
+    code = nodesMergeConds(&pTempRemainCond, &pRemainConds);
   }
 
   if (TSDB_CODE_SUCCESS == code) {

source/libs/planner/test/planOptimizeTest.cpp

@@ -36,6 +36,10 @@ TEST_F(PlanOptimizeTest, ConditionPushDown) {
   useDb("root", "test");
 
   run("SELECT ts, c1 FROM st1 WHERE tag1 > 4");
+
+  run("SELECT ts, c1 FROM st1 WHERE tag1 > 4 or tag1 < 2");
+
+  run("SELECT ts, c1 FROM st1 WHERE tag1 > 4 AND tag2 = 'hello'");
 }
 
 TEST_F(PlanOptimizeTest, orderByPrimaryKey) {