Merge branch '3.0' of https://github.com/taosdata/TDengine into feat/row_refact

Jenkinsfile2

@@ -4,8 +4,10 @@ import jenkins.model.CauseOfInterruption
 node {
 }
 
-def skipbuild=0
-def win_stop=0
+win_test_stage = 0
+linux_ready = 0
+linux_node_ip = ""
+linux_node_pass = ""
 
 def abortPreviousBuilds() {
     def currentJobName = env.JOB_NAME
@@ -227,6 +229,16 @@ def pre_test_win(){
         cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\community
         git submodule update --init --recursive
     '''
+    bat '''
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\taos-connector-python
+        git branch
+        git reset --hard
+        git pull
+    '''
+    bat '''
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\taos-connector-python
+        git log -5
+    '''
 }
 def pre_test_build_win() {
     bat '''
@@ -246,8 +258,38 @@ def pre_test_build_win() {
         jom -j 6 || exit 8
         time /t
     '''
+    bat '''
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\taos-connector-python
+        python -m pip install .
+        xcopy /e/y/i/f C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
+    '''
     return 1
 }
+def run_win_ctest() {
+    bat '''
+        echo "windows ctest ..."
+        time /t
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\debug
+        ctest -j 1 || exit 7
+        time /t
+    '''
+}
+def run_win_test() {
+    echo "LINUX NODE: ${linux_node_ip} - ${linux_node_pass}"
+    bat '''
+        echo "windows test ..."
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\taos-connector-python
+        python -m pip install .
+        xcopy /e/y/i/f C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
+        ls -l C:\\Windows\\System32\\taos.dll
+        time /t
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\community\\tests\\system-test
+        echo "node: ''' + linux_node_ip + ''':''' + linux_node_pass + '''"
+        echo "testing ..."
+        test-all.bat  "{\\\"host\\\":\\\"''' + linux_node_ip + '''\\\",\\\"port\\\":22,\\\"user\\\":\\\"root\\\",\\\"password\\\":\\\"''' + linux_node_pass + '''\\\",\\\"path\\\":\\\"/var/lib/jenkins/workspace/TDinternal\\\"}"
+        time /t
+    '''
+}
 
 pipeline {
     agent none
@@ -264,8 +306,22 @@ pipeline {
                 stage('windows test') {
                     agent{label " windows10_01 || windows10_02 || windows10_03 || windows10_04 "}
                     steps {
-                        pre_test_win()
-                        pre_test_build_win()
+                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+                            timeout(time: 55, unit: 'MINUTES'){
+                                pre_test_win()
+                                pre_test_build_win()
+                                run_win_ctest()
+                                script {
+                                    while(linux_ready == 0) {
+                                        sleep(8)
+                                    }
+                                }
+                                run_win_test()
+                            }
+                        }
+                        script {
+                            win_test_stage = 1
+                        }
                     }
                 }
                 stage('linux test') {
@@ -275,22 +331,78 @@ pipeline {
                         changeRequest()
                     }
                     steps {
-                        timeout(time: 40, unit: 'MINUTES'){
-                            pre_test()
-                            script {
-                                sh '''
-                                    cd ${WKC}/tests/parallel_test
-                                    date
-                                    time ./container_build.sh -w ${WKDIR} -t 8 -e
-                                    rm -f /tmp/cases.task
-                                    ./collect_cases.sh -e
-                                '''
-                                sh '''
-                                    cd ${WKC}/tests/parallel_test
-                                    export DEFAULT_RETRY_TIME=2
-                                    date
-                                    timeout 2100 time ./run.sh -e -m /home/m.json -t /tmp/cases.task -b ${BRANCH_NAME}_${BUILD_ID} -l ${WKDIR}/log -o 480
-                                '''
+                        script {
+                            linux_node_ip = sh (
+                                script: 'jq .ip /home/node_info.json | sed "s/\\\"//g"',
+                                returnStdout: true
+                            ).trim()
+                            linux_node_pass = sh (
+                                script: 'jq .password /home/node_info.json | sed "s/\\\"//g" |sed "s/\\!/^^^^^^^^\\!/g"',
+                                returnStdout: true
+                            ).trim()
+                            echo "${linux_node_ip}:${linux_node_pass}"
+                        }
+                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+                            timeout(time: 40, unit: 'MINUTES'){
+                                pre_test()
+                                script {
+                                    sh '''
+                                        date
+                                        rm -rf ${WKC}/debug
+                                        cd ${WKC}/tests/parallel_test
+                                        time ./container_build.sh -w ${WKDIR} -t 8 -e
+                                        rm -f /tmp/cases.task
+                                        ./collect_cases.sh -e
+                                    '''
+                                    sh '''
+                                        cd ${WKC}/tests/parallel_test
+                                        export DEFAULT_RETRY_TIME=2
+                                        date
+                                        timeout 2100 time ./run.sh -e -m /home/m.json -t /tmp/cases.task -b ${BRANCH_NAME}_${BUILD_ID} -l ${WKDIR}/log -o 480
+                                    '''
+                                }
+                            }
+                        }
+                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+                            timeout(time: 15, unit: 'MINUTES'){
+                                script {
+                                    sh '''
+                                        echo "packaging ..."
+                                        date
+                                        rm -rf ${WKC}/release/*
+                                        cd ${WKC}/packaging
+                                        ./release.sh -v cluster -n 3.0.0.100 -s static
+                                    '''
+                                    sh '''
+                                        echo "install ..."
+                                        cd ${WKC}/release
+                                        tar xzf TDengine-enterprise-server-3.0.0.100-Linux-x64.tar.gz
+                                        cd TDengine-enterprise-server-3.0.0.100
+                                        service taosd stop || :
+                                        rm -rf /var/lib/taos
+                                        ./install.sh -e no
+                                    '''
+                                    sh '''
+                                        echo "checking ..."
+                                        which taos
+                                        which taosd
+                                        rm -rf ${WK}/debug
+                                        mv ${WKC}/debug ${WK}/
+                                    '''
+                                    sh '''
+                                        echo "install taospy ..."
+                                        cd ${WKPY}
+                                        pip3 install .
+                                    '''
+                                }
+                            }
+                        }
+                        script {
+                            linux_ready = 1
+                        }
+                        script {
+                            while(win_test_stage == 0){
+                                sleep(12)
                             }
                         }
                     }

include/common/tmsg.h

@@ -2397,16 +2397,26 @@ static int32_t tDecodeTSmaWrapper(SDecoder* pDecoder, STSmaWrapper* pReq) {
 }
 
 typedef struct {
-  int64_t tsmaIndexUid;
+  int64_t indexUid;
   STimeWindow queryWindow;
 } SVGetTsmaExpWndsReq;
 
+#define SMA_WNDS_EXPIRE_FLAG      (0x1)
+#define SMA_WNDS_IS_EXPIRE(flag)  (((flag)&SMA_WNDS_EXPIRE_FLAG) != 0)
+#define SMA_WNDS_SET_EXPIRE(flag) ((flag) |= SMA_WNDS_EXPIRE_FLAG)
+
 typedef struct {
-  int64_t tsmaIndexUid;
+  int64_t indexUid;
+  int8_t  flags;  // 0x1 all window expired
   int32_t numExpWnds;
-  TSKEY*  expWndsStartTs;
+  TSKEY   wndSKeys[];
 } SVGetTsmaExpWndsRsp;
 
+int32_t tEncodeSVGetTSmaExpWndsReq(SEncoder* pCoder, const SVGetTsmaExpWndsReq* pReq);
+int32_t tDecodeSVGetTsmaExpWndsReq(SDecoder* pCoder, SVGetTsmaExpWndsReq* pReq);
+int32_t tEncodeSVGetTSmaExpWndsRsp(SEncoder* pCoder, const SVGetTsmaExpWndsRsp* pReq);
+int32_t tDecodeSVGetTsmaExpWndsRsp(SDecoder* pCoder, SVGetTsmaExpWndsRsp* pReq);
+
 typedef struct {
   int idx;
 } SMCreateFullTextReq;
@@ -2670,23 +2680,27 @@ typedef struct {
 int32_t tEncodeSVSubmitReq(SEncoder* pCoder, const SVSubmitReq* pReq);
 int32_t tDecodeSVSubmitReq(SDecoder* pCoder, SVSubmitReq* pReq);
 
-// TDMT_VND_DELETE
 typedef struct {
-  TSKEY sKey;
-  TSKEY eKey;
-
-  // super table
-  char* stbName;
-
-  // child/normal
-  char* tbName;
+  int64_t     delUid;
+  int64_t     tbUid;  // super/child/normal table
+  int8_t      type;   // table type
+  int16_t     nWnds;
+  char*       tbFullName;
+  char*       subPlan;
+  STimeWindow wnds[];
 } SVDeleteReq;
 
+int32_t tEncodeSVDeleteReq(SEncoder* pCoder, const SVDeleteReq* pReq);
+int32_t tDecodeSVDeleteReq(SDecoder* pCoder, SVDeleteReq* pReq);
+
 typedef struct {
   int32_t code;
-  // TODO
+  int64_t affectedRows;
 } SVDeleteRsp;
 
+int32_t tEncodeSVDeleteRsp(SEncoder* pCoder, const SVDeleteRsp* pReq);
+int32_t tDecodeSVDeleteRsp(SDecoder* pCoder, SVDeleteRsp* pReq);
+
 #pragma pack(pop)
 
 #ifdef __cplusplus

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/common/src/tmsg.c

@@ -3742,6 +3742,111 @@ int32_t tDecodeSVDropTSmaReq(SDecoder *pCoder, SVDropTSmaReq *pReq) {
   return 0;
 }
 
+int32_t tEncodeSVGetTSmaExpWndsReq(SEncoder* pCoder, const SVGetTsmaExpWndsReq* pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI64(pCoder, pReq->indexUid) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->queryWindow.skey) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->queryWindow.ekey) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;  
+}
+
+int32_t tDecodeSVGetTsmaExpWndsReq(SDecoder* pCoder, SVGetTsmaExpWndsReq* pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI64(pCoder, &pReq->indexUid) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->queryWindow.skey) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->queryWindow.ekey) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVGetTSmaExpWndsRsp(SEncoder* pCoder, const SVGetTsmaExpWndsRsp* pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI64(pCoder, pReq->indexUid) < 0) return -1;
+  if (tEncodeI8(pCoder, pReq->flags) < 0) return -1;
+  if (tEncodeI32(pCoder, pReq->numExpWnds) < 0) return -1;
+  for (int32_t i = 0; i < pReq->numExpWnds; ++i) {
+    if (tEncodeI64(pCoder, pReq->wndSKeys[i]) < 0) return -1;
+  }
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVGetTsmaExpWndsRsp(SDecoder *pCoder, SVGetTsmaExpWndsRsp *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI64(pCoder, &pReq->indexUid) < 0) return -1;
+  if (tDecodeI8(pCoder, &pReq->flags) < 0) return -1;
+  if (tDecodeI32(pCoder, &pReq->numExpWnds) < 0) return -1;
+  for (int32_t i = 0; i < pReq->numExpWnds; ++i) {
+    if (tDecodeI64(pCoder, &pReq->wndSKeys[i]) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVDeleteReq(SEncoder* pCoder, const SVDeleteReq* pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI64(pCoder, pReq->delUid) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->tbUid) < 0) return -1;
+  if (tEncodeI8(pCoder, pReq->type) < 0) return -1;
+  if (tEncodeI16v(pCoder, pReq->nWnds) < 0) return -1;
+  if (tEncodeCStr(pCoder, pReq->tbFullName) < 0) return -1;
+  if (tEncodeCStr(pCoder, pReq->subPlan) < 0) return -1;
+  for (int16_t i = 0; i < pReq->nWnds; ++i) {
+    if (tEncodeI64(pCoder, pReq->wnds[i].skey) < 0) return -1;
+    if (tEncodeI64(pCoder, pReq->wnds[i].ekey) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVDeleteReq(SDecoder* pCoder, SVDeleteReq* pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI64(pCoder, &pReq->delUid) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->tbUid) < 0) return -1;
+  if (tDecodeI8(pCoder, &pReq->type) < 0) return -1;
+  if (tDecodeI16v(pCoder, &pReq->nWnds) < 0) return -1;
+  if (tDecodeCStr(pCoder, &pReq->tbFullName) < 0) return -1;
+  if (tDecodeCStr(pCoder, &pReq->subPlan) < 0) return -1;
+  for (int16_t i = 0; i < pReq->nWnds; ++i) {
+    if (tDecodeI64(pCoder, &pReq->wnds[i].skey) < 0) return -1;
+    if (tDecodeI64(pCoder, &pReq->wnds[i].ekey) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVDeleteRsp(SEncoder* pCoder, const SVDeleteRsp* pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32(pCoder, pReq->code) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->affectedRows) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVDeleteRsp(SDecoder* pCoder, SVDeleteRsp* pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32(pCoder, &pReq->code) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->affectedRows) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
 int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {
   int32_t sqlLen = 0;
   int32_t astLen = 0;

source/libs/executor/inc/executorimpl.h

@@ -503,7 +503,7 @@ typedef struct SProjectOperatorInfo {
   // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode
   SOptrBasicInfo     binfo;
   SAggSupporter      aggSup;
-
+  SNode*             pFilterNode;  // filter info, which is push down by optimizer
   SSDataBlock*       existDataBlock;
   SArray*            pPseudoColInfo;
   SLimit             limit;
@@ -706,7 +706,7 @@ int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t *order, int32_t* scan
 int32_t getBufferPgSize(int32_t rowSize, uint32_t* defaultPgsz, uint32_t* defaultBufsz);
 
 void    doSetOperatorCompleted(SOperatorInfo* pOperator);
-void    doFilter(const SNode* pFilterNode, SSDataBlock* pBlock, SArray* pColMatchInfo);
+void    doFilter(const SNode* pFilterNode, SSDataBlock* pBlock);
 SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowCellInfoOffset);
 void    relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols);
 void    initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow);
@@ -738,7 +738,7 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode,
 SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResultBlock, SExprInfo* pScalarExprInfo,
                                            int32_t numOfScalarExpr, SExecTaskInfo* pTaskInfo);
 
-SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t num, SSDataBlock* pResBlock, SLimit* pLimit, SLimit* pSlimit, SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t num, SSDataBlock* pResBlock, SLimit* pLimit, SLimit* pSlimit, SNode* pCondition, SExecTaskInfo* pTaskInfo);
 SOperatorInfo *createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock, SArray* pSortInfo, SExprInfo* pExprInfo, int32_t numOfCols,
                                       SArray* pIndexMap, SExecTaskInfo* pTaskInfo);
 

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
-
   }
 }
 
@@ -1824,7 +1821,8 @@ void setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numO
 }
 
 static void extractQualifiedTupleByFilterResult(SSDataBlock* pBlock, const int8_t* rowRes, bool keep);
-void        doFilter(const SNode* pFilterNode, SSDataBlock* pBlock, SArray* pColMatchInfo) {
+
+void doFilter(const SNode* pFilterNode, SSDataBlock* pBlock) {
   if (pFilterNode == NULL) {
     return;
   }
@@ -3669,6 +3667,8 @@ static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
       longjmp(pTaskInfo->env, code);
     }
 
+    doFilter(pProjectInfo->pFilterNode, pBlock);
+
     setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order, scanFlag, false);
     blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows);
 
@@ -4044,7 +4044,7 @@ static SArray* setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols)
 }
 
 SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t num,
-                                         SSDataBlock* pResBlock, SLimit* pLimit, SLimit* pSlimit,
+                                         SSDataBlock* pResBlock, SLimit* pLimit, SLimit* pSlimit, SNode* pCondition,
                                          SExecTaskInfo* pTaskInfo) {
   SProjectOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SProjectOperatorInfo));
   SOperatorInfo*        pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
@@ -4052,12 +4052,12 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* p
     goto _error;
   }
 
-  pInfo->limit = *pLimit;
-  pInfo->slimit = *pSlimit;
-  pInfo->curOffset = pLimit->offset;
+  pInfo->limit      = *pLimit;
+  pInfo->slimit     = *pSlimit;
+  pInfo->curOffset  = pLimit->offset;
   pInfo->curSOffset = pSlimit->offset;
-
   pInfo->binfo.pRes = pResBlock;
+  pInfo->pFilterNode= pCondition;
 
   int32_t numOfCols = num;
   int32_t numOfRows = 4096;
@@ -4259,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;
@@ -4302,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) {
@@ -4389,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;
@@ -4417,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;
@@ -4486,7 +4487,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
     SLimit       limit = {.limit = pProjPhyNode->limit, .offset = pProjPhyNode->offset};
     SLimit       slimit = {.limit = pProjPhyNode->slimit, .offset = pProjPhyNode->soffset};
-    pOptr = createProjectOperatorInfo(ops[0], pExprInfo, num, pResBlock, &limit, &slimit, pTaskInfo);
+    pOptr = createProjectOperatorInfo(ops[0], pExprInfo, num, pResBlock, &limit, &slimit, pProjPhyNode->node.pConditions, pTaskInfo);
   } else if (QUERY_NODE_PHYSICAL_PLAN_AGG == type) {
     SAggPhysiNode* pAggNode = (SAggPhysiNode*)pPhyNode;
     SExprInfo*     pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num);
@@ -4519,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;
       }
     }
@@ -5205,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/executor/src/groupoperator.c

@@ -341,7 +341,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
 
   while(1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pInfo->pCondition, pRes, NULL);
+    doFilter(pInfo->pCondition, pRes);
 
     bool hasRemain = hashRemainDataInGroupInfo(&pInfo->groupResInfo);
     if (!hasRemain) {

source/libs/executor/src/scanoperator.c

@@ -256,7 +256,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
   }
 
   int64_t st = taosGetTimestampMs();
-  doFilter(pTableScanInfo->pFilterNode, pBlock, pTableScanInfo->pColMatchInfo);
+  doFilter(pTableScanInfo->pFilterNode, pBlock);
 
   int64_t et = taosGetTimestampMs();
   pTableScanInfo->readRecorder.filterTime += (et - st);
@@ -894,7 +894,7 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator) {
         addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes);
       }
 
-      doFilter(pInfo->pCondition, pInfo->pRes, NULL);
+      doFilter(pInfo->pCondition, pInfo->pRes);
       blockDataUpdateTsWindow(pInfo->pRes, 0);
       break;
     }

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) {

tests/system-test/1-insert/alter_stable.py

+###################################################################
+#           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 random
+import string
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def get_long_name(self, length, mode="mixed"):
+        """
+        generate long name
+        mode could be numbers/letters/letters_mixed/mixed
+        """
+        if mode == "numbers":
+            population = string.digits
+        elif mode == "letters":
+            population = string.ascii_letters.lower()
+        elif mode == "letters_mixed":
+            population = string.ascii_letters.upper() + string.ascii_letters.lower()
+        else:
+            population = string.ascii_letters.lower() + string.digits
+        return "".join(random.choices(population, k=length))
+    def alter_stable_column_check(self,dbname,stbname,tbname):
+        tdSql.execute(f'create database if not exists {dbname}')
+        tdSql.execute(f'use {dbname}')
+        tdSql.execute(
+            f'create stable {stbname} (ts timestamp, c1 tinyint, c2 smallint, c3 int, \
+                c4 bigint, c5 tinyint unsigned, c6 smallint unsigned, c7 int unsigned, c8 bigint unsigned, c9 float, c10 double, c11 bool,c12 binary(20),c13 nchar(20)) tags(t0 int) ')
+        tdSql.execute(f'create table {tbname} using {stbname} tags(1)')
+        tdSql.execute(f'insert into {tbname} values (now,1,2,3,4,5,6,7,8,9.9,10.1,true,"abcd","涛思数据")')
+        tdSql.execute(f'alter stable {stbname} add column c14 int')
+        tdSql.query(f'select c14 from {stbname}')
+        tdSql.checkRows(1)
+        tdSql.execute(f'alter stable {stbname} add column `c15` int')
+        tdSql.query(f'select c15 from {stbname}')
+        tdSql.checkRows(1)
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(17)
+        tdSql.execute(f'alter stable {stbname} drop column c14')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(16)
+        tdSql.execute(f'alter stable {stbname} drop column `c15`')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(15)
+        tdSql.execute(f'alter stable {stbname} modify column c12 binary(30)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(12,2,30)
+        tdSql.execute(f'alter stable {stbname} modify column `c12` binary(35)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(12,2,35)
+        tdSql.error(f'alter stable {stbname} modify column `c12` binary(34)')
+        tdSql.execute(f'alter stable {stbname} modify column c13 nchar(30)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(13,2,30)
+        tdSql.error(f'alter stable {stbname} modify column c13 nchar(29)')
+        tdSql.error(f'alter stable {stbname} rename column c1 c21')
+        tdSql.error(f'alter stable {stbname} modify column c1 int')
+        tdSql.error(f'alter stable {stbname} modify column c4 int')
+        tdSql.error(f'alter stable {stbname} modify column c8 int')
+        tdSql.error(f'alter stable {stbname} modify column c1 unsigned int')
+        tdSql.error(f'alter stable {stbname} modify column c9 double')
+        tdSql.error(f'alter stable {stbname} modify column c10 float')
+        tdSql.error(f'alter stable {stbname} modify column c11 int')
+        tdSql.execute(f'drop database {dbname}')
+
+    def alter_stable_tag_check(self,dbname,stbname,tbname):
+        tdSql.execute(f'create database if not exists {dbname}')
+        tdSql.execute(f'use {dbname}')
+        tdSql.execute(
+            f'create stable {stbname} (ts timestamp, c1 int) tags(ts_tag timestamp, t1 tinyint, t2 smallint, t3 int, \
+                t4 bigint, t5 tinyint unsigned, t6 smallint unsigned, t7 int unsigned, t8 bigint unsigned, t9 float, t10 double, t11 bool,t12 binary(20),t13 nchar(20)) ')
+        tdSql.execute(f'create table {tbname} using {stbname} tags(now,1,2,3,4,5,6,7,8,9.9,10.1,true,"abcd","涛思数据")')
+        tdSql.execute(f'insert into {tbname} values(now,1)')
+
+        tdSql.execute(f'alter stable {stbname} add tag t14 int')
+        tdSql.query(f'select t14 from {stbname}')
+        tdSql.checkRows(1)
+        tdSql.execute(f'alter stable {stbname} add tag `t15` int')
+        tdSql.query(f'select t14 from {stbname}')
+        tdSql.checkRows(1)
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(18)
+        tdSql.execute(f'alter stable {stbname} drop tag t14')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(17)
+        tdSql.execute(f'alter stable {stbname} drop tag `t15`')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkRows(16)
+        tdSql.execute(f'alter stable {stbname} modify tag t12 binary(30)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(14,2,30)
+        tdSql.execute(f'alter stable {stbname} modify tag `t12` binary(35)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(14,2,35)
+        tdSql.error(f'alter stable {stbname} modify tag `t12` binary(34)')
+        tdSql.execute(f'alter stable {stbname} modify tag t13 nchar(30)')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(15,2,30)
+        tdSql.error(f'alter stable {stbname} modify tag t13 nchar(29)')
+        tdSql.execute(f'alter table {stbname} rename tag t1 t21')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(3,0,'t21')
+        tdSql.execute(f'alter table {stbname} rename tag `t21` t1')
+        tdSql.query(f'describe {stbname}')
+        tdSql.checkData(3,0,'t1')
+
+        for i in ['bigint','unsigned int','float','double','binary(10)','nchar(10)']:
+            for j in [1,2,3]:
+                tdSql.error(f'alter table {stbname} modify tag t{j} {i}')
+        for i in ['int','unsigned int','float','binary(10)','nchar(10)']:
+            tdSql.error(f'alter table {stbname} modify tag t8 {i}')
+        tdSql.error(f'alter table {stbname} modify tag t4 int')
+        tdSql.execute(f'drop database {dbname}')
+
+    def run(self):
+
+        dbname = self.get_long_name(length=10, mode="letters")
+        stbname = self.get_long_name(length=5, mode="letters")
+        tbname = self.get_long_name(length=5, mode="letters")
+        self.alter_stable_column_check(dbname,stbname,tbname)
+        self.alter_stable_tag_check(dbname,stbname,tbname)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file

tests/system-test/1-insert/alter_table.py

+###################################################################
+#           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 random
+import string
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def get_long_name(self, length, mode="mixed"):
+        """
+        generate long name
+        mode could be numbers/letters/letters_mixed/mixed
+        """
+        if mode == "numbers":
+            population = string.digits
+        elif mode == "letters":
+            population = string.ascii_letters.lower()
+        elif mode == "letters_mixed":
+            population = string.ascii_letters.upper() + string.ascii_letters.lower()
+        else:
+            population = string.ascii_letters.lower() + string.digits
+        return "".join(random.choices(population, k=length))
+
+    def alter_tb_tag_check(self):
+        tag_tinyint = random.randint(-127,129)
+        tag_int = random.randint(-2147483648,2147483647)
+        tag_smallint = random.randint(-32768,32768)
+        tag_bigint = random.randint(-2147483648,2147483647)
+        tag_untinyint = random.randint(0,256)
+        tag_unsmallint = random.randint(0,65536)
+        tag_unint = random.randint(0,4294967296)
+        tag_unbigint = random.randint(0,2147483647)
+        tag_binary = self.get_long_name(length=10, mode="letters")
+        tag_nchar = self.get_long_name(length=10, mode="letters")
+        dbname = self.get_long_name(length=10, mode="letters")
+        tdSql.execute(f'create database if not exists {dbname}')
+        stbname = self.get_long_name(length=3, mode="letters")
+        tbname = self.get_long_name(length=3, mode="letters")
+        tdLog.info('--------------------------child table tag check--------------------------------------')
+        tdLog.info(f'-----------------create stable {stbname} and child table {tbname}-------------------')
+        tdSql.execute(f'create stable if not exists {dbname}.{stbname} (col_ts timestamp, c1 int) tags (tag_ts timestamp, t1 tinyint, t2 smallint, t3 int, \
+                t4 bigint, t5 tinyint unsigned, t6 smallint unsigned, t7 int unsigned, t8 bigint unsigned, t9 float, t10 double, t11 bool,t12 binary(20),t13 nchar(20))')
+        tdSql.execute(f'create table if not exists {dbname}.{tbname} using {dbname}.{stbname} tags(now, 1, 2, 3, 4, 5, 6, 7, 8, 9.9, 10.1, True,"abc123","涛思数据")')
+        tdSql.execute(f'insert into {dbname}.{tbname} values(now, 1)')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag tag_ts = 1640966400000')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag `t1` = 11')
+        tdSql.query(f'select * from {dbname}.{stbname}')
+        tdSql.checkData(0,3,11)
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t1 = {tag_tinyint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t2 = {tag_smallint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t3 = {tag_int}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t4 = {tag_bigint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t5 = {tag_untinyint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t6 = {tag_unsmallint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t7 = {tag_unint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t8 = {tag_unbigint}')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t11 = false')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t12 = "{tag_binary}"')
+        tdSql.execute(f'alter table {dbname}.{tbname} set tag t13 = "{tag_nchar}"')
+        tdSql.query(f'select * from {dbname}.{stbname}')
+        # bug TD-15899
+        tdSql.checkData(0,2,'2022-01-01 00:00:00.000')
+        tdSql.checkData(0,3,tag_tinyint)
+        tdSql.checkData(0,4,tag_smallint)
+        tdSql.checkData(0,5,tag_int)
+        tdSql.checkData(0,6,tag_bigint)
+        tdSql.checkData(0,7,tag_untinyint)
+        tdSql.checkData(0,8,tag_unsmallint)
+        tdSql.checkData(0,9,tag_unint)
+        tdSql.checkData(0,10,tag_unbigint)
+        
+        tdSql.checkData(0,13,False)
+        tdSql.checkData(0,14,tag_binary)
+        tdSql.checkData(0,15,tag_nchar)
+
+        # bug TD-16211 insert length more than setting binary and nchar
+        # tag_binary = self.get_long_name(length=21, mode="letters")
+        # tag_nchar = self.get_long_name(length=21, mode="letters")
+        # tdSql.error(f'alter table {dbname}.{tbname} set tag t12 = "{tag_binary}"')
+        # tdSql.error(f'alter table {dbname}.{tbname} set tag t13 = "{tag_nchar}"')
+
+        # bug TD-16210 modify binary to nchar
+        # tdSql.error(f'alter table {dbname}.{tbname} modify tag t12 nchar(10)')
+        tdSql.execute(f"drop database {dbname}")
+    def alter_ntb_column_check(self):
+        '''
+        alter ntb column check
+        '''
+        dbname = self.get_long_name(length=10, mode="letters")
+        tdSql.execute(f'create database if not exists {dbname}')
+        tbname = self.get_long_name(length=3, mode="letters")
+        tdLog.info('------------------normal table column check---------------------')
+        tdLog.info(f'-----------------create normal table {tbname}-------------------')
+        tdSql.execute(f'create table if not exists {dbname}.{tbname} (ts timestamp, c1 tinyint, c2 smallint, c3 int, \
+                c4 bigint, c5 tinyint unsigned, c6 smallint unsigned, c7 int unsigned, c8 bigint unsigned, c9 float, c10 double, c11 bool,c12 binary(20),c13 nchar(20))')
+        tdSql.execute(f'insert into {dbname}.{tbname} values (now,1,2,3,4,5,6,7,8,9.9,10.1,true,"abcd","涛思数据")')
+        # bug TD-15757
+        tdSql.execute(f'alter table {dbname}.{tbname} add column c14 int')
+        tdSql.query(f'select c14 from {dbname}.{tbname}')
+        tdSql.checkRows(1)
+        tdSql.execute(f'alter table {dbname}.{tbname} add column `c15` int')
+        tdSql.query(f'select c15 from {dbname}.{tbname}')
+        tdSql.checkRows(1)
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkRows(16)
+        tdSql.execute(f'alter table {dbname}.{tbname} drop column c14')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkRows(15)
+        tdSql.execute(f'alter table {dbname}.{tbname} drop column `c15`')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkRows(14)
+        tdSql.execute(f'alter table {dbname}.{tbname} modify column c12 binary(30)')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(12,2,30)
+        tdSql.execute(f'alter table {dbname}.{tbname} modify column `c12` binary(35)')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(12,2,35)
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c12 binary(34)')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c12 nchar(10)')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c12 int')
+        tdSql.execute(f'alter table {dbname}.{tbname} modify column c13 nchar(30)')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(13,2,30)
+        tdSql.execute(f'alter table {dbname}.{tbname} modify column `c13` nchar(35)')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(13,2,35)
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c13 nchar(34)')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c13 binary(10)')
+        tdSql.execute(f'alter table {dbname}.{tbname} rename column c1 c21')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(1,0,'c21')
+        tdSql.execute(f'alter table {dbname}.{tbname} rename column `c21` c1')
+        tdSql.query(f'describe {dbname}.{tbname}')
+        tdSql.checkData(1,0,'c1')
+
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c1 bigint')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c1 double')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c4 int')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column `c1` double')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c9 double')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c10 float')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c1 bool')
+        tdSql.error(f'alter table {dbname}.{tbname} modify column c1 binary(10)')
+        tdSql.execute(f'drop database {dbname}')
+    def run(self):
+        self.alter_tb_tag_check()
+        self.alter_ntb_column_check()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file

tests/system-test/fulltest.sh

@@ -19,7 +19,8 @@ python3 ./test.py -f 1-insert/influxdb_line_taosc_insert.py
 python3 ./test.py -f 1-insert/opentsdb_telnet_line_taosc_insert.py
 python3 ./test.py -f 1-insert/opentsdb_json_taosc_insert.py
 #python3 ./test.py -f 1-insert/test_stmt_muti_insert_query.py
-
+python3 ./test.py -f 1-insert/alter_stable.py
+python3 ./test.py -f 1-insert/alter_table.py
 python3 ./test.py -f 2-query/between.py
 python3 ./test.py -f 2-query/distinct.py
 python3 ./test.py -f 2-query/varchar.py
@@ -79,6 +80,7 @@ python3 ./test.py -f 2-query/query_cols_tags_and_or.py
 # TD-15983 subquery output duplicate name column. 
 # Please Xiangyang Guo modify the following script
 # python3 ./test.py -f 2-query/nestedQuery_str.py
+
 python3 ./test.py -f 2-query/avg.py
 python3 ./test.py -f 2-query/elapsed.py
 python3 ./test.py -f 2-query/csum.py