Merge pull request #28925 from taosdata/feat/updateMultiTag

Feat/updateMultiTag

docs/en/14-reference/03-taos-sql/03-table.md

@@ -169,7 +169,7 @@ ALTER TABLE [db_name.]tb_name alter_table_clause
 
 alter_table_clause: {
     alter_table_options
-  | SET TAG tag_name = new_tag_value
+  | SET TAG tag_name = new_tag_value,tag_name2=new_tag2_value...
 }
 
 alter_table_options:

docs/zh/14-reference/03-taos-sql/03-table.md

@@ -171,7 +171,7 @@ ALTER TABLE [db_name.]tb_name alter_table_clause
 
 alter_table_clause: {
     alter_table_options
-  | SET TAG tag_name = new_tag_value
+  | SET TAG tag_name = new_tag_value,tag_name2=new_tag2_value...
 }
 
 alter_table_options:

include/common/tmsg.h

@@ -178,6 +178,7 @@ typedef enum _mgmt_table {
 #define TSDB_ALTER_TABLE_DROP_TAG_INDEX                  12
 #define TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS          13
 #define TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION 14
+#define TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL            15
 
 #define TSDB_FILL_NONE        0
 #define TSDB_FILL_NULL        1
@@ -985,7 +986,6 @@ typedef struct SEpSet {
   SEp    eps[TSDB_MAX_REPLICA];
 } SEpSet;
 
-
 int32_t tEncodeSEpSet(SEncoder* pEncoder, const SEpSet* pEp);
 int32_t tDecodeSEpSet(SDecoder* pDecoder, SEpSet* pEp);
 int32_t taosEncodeSEpSet(void** buf, const SEpSet* pEp);
@@ -3259,6 +3259,16 @@ int32_t tEncodeSVDropTbBatchRsp(SEncoder* pCoder, const SVDropTbBatchRsp* pRsp);
 int32_t tDecodeSVDropTbBatchRsp(SDecoder* pCoder, SVDropTbBatchRsp* pRsp);
 
 // TDMT_VND_ALTER_TABLE =====================
+typedef struct SMultiTagUpateVal {
+  char*    tagName;
+  int32_t  colId;
+  int8_t   tagType;
+  int8_t   tagFree;
+  uint32_t nTagVal;
+  uint8_t* pTagVal;
+  int8_t   isNull;
+  SArray*  pTagArray;
+} SMultiTagUpateVal;
 typedef struct {
   char*   tbName;
   int8_t  action;
@@ -3288,11 +3298,13 @@ typedef struct {
   int64_t  ctimeMs;    // fill by vnode
   int8_t   source;     // TD_REQ_FROM_TAOX-taosX or TD_REQ_FROM_APP-taosClient
   uint32_t compress;   // TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS
+  SArray*  pMultiTag;  // TSDB_ALTER_TABLE_ADD_MULTI_TAGS
 } SVAlterTbReq;
 
 int32_t tEncodeSVAlterTbReq(SEncoder* pEncoder, const SVAlterTbReq* pReq);
 int32_t tDecodeSVAlterTbReq(SDecoder* pDecoder, SVAlterTbReq* pReq);
 int32_t tDecodeSVAlterTbReqSetCtime(SDecoder* pDecoder, SVAlterTbReq* pReq, int64_t ctimeMs);
+void    tfreeMultiTagUpateVal(void* pMultiTag);
 
 typedef struct {
   int32_t        code;
@@ -4143,11 +4155,11 @@ typedef struct {
   SArray*      blockTbName;
   SArray*      blockSchema;
 
-  union{
+  union {
-    struct{
+    struct {
       int64_t sleepTime;
     };
-    struct{
+    struct {
       int32_t createTableNum;
       SArray* createTableLen;
       SArray* createTableReq;
@@ -4156,7 +4168,7 @@ typedef struct {
 
 } SMqDataRsp;
 
-int32_t tEncodeMqDataRsp(SEncoder *pEncoder, const SMqDataRsp *pObj);
+int32_t tEncodeMqDataRsp(SEncoder* pEncoder, const SMqDataRsp* pObj);
 int32_t tDecodeMqDataRsp(SDecoder* pDecoder, SMqDataRsp* pRsp);
 void    tDeleteMqDataRsp(SMqDataRsp* pRsp);
 

include/libs/nodes/cmdnodes.h

@@ -264,8 +264,18 @@ typedef struct SAlterTableStmt {
   SDataType       dataType;
   SValueNode*     pVal;
   SColumnOptions* pColOptions;
+  SNodeList*      pNodeListTagValue;
 } SAlterTableStmt;
 
+typedef struct SAlterTableMultiStmt {
+  ENodeType type;
+  char      dbName[TSDB_DB_NAME_LEN];
+  char      tableName[TSDB_TABLE_NAME_LEN];
+  int8_t    alterType;
+
+  SNodeList* pNodeListTagValue;
+} SAlterTableMultiStmt;
+
 typedef struct SCreateUserStmt {
   ENodeType   type;
   char        userName[TSDB_USER_LEN];

source/client/src/clientRawBlockWrite.c

@@ -620,7 +620,10 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
   cJSON* type = cJSON_CreateString("alter");
   RAW_NULL_CHECK(type);
   RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
-  cJSON* tableType = cJSON_CreateString(vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_TAG_VAL ? "child" : "normal");
+  cJSON* tableType = cJSON_CreateString(vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_TAG_VAL ||
+                                                vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL
+                                            ? "child"
+                                            : "normal");
   RAW_NULL_CHECK(tableType);
   RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
   cJSON* tableName = cJSON_CreateString(vAlterTbReq.tbName);
@@ -762,6 +765,58 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
       RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colValueNull", isNullCJson));
       break;
     }
+    case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL: {
+      int32_t nTags = taosArrayGetSize(vAlterTbReq.pMultiTag);
+      if (nTags <= 0) {
+        uError("processAlterTable parse multi tags error");
+        goto end;
+      }
+
+      cJSON* tags = cJSON_CreateArray();
+      RAW_NULL_CHECK(tags);
+      for (int32_t i = 0; i < nTags; i++) {
+        cJSON* member = cJSON_CreateObject();
+        RAW_NULL_CHECK(member);
+
+        SMultiTagUpateVal* pTagVal = taosArrayGet(vAlterTbReq.pMultiTag, i);
+        cJSON*             tagName = cJSON_CreateString(pTagVal->tagName);
+        RAW_NULL_CHECK(tagName);
+        RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colName", tagName));
+
+        if (pTagVal->tagType == TSDB_DATA_TYPE_JSON) {
+          uError("processAlterTable isJson false");
+          goto end;
+        }
+        bool isNull = pTagVal->isNull;
+        if (!isNull) {
+          char*   buf = NULL;
+          int64_t bufSize = 0;
+          if (pTagVal->tagType == TSDB_DATA_TYPE_VARBINARY) {
+            bufSize = pTagVal->nTagVal * 2 + 2 + 3;
+          } else {
+            bufSize = pTagVal->nTagVal + 3;
+          }
+          buf = taosMemoryCalloc(bufSize, 1);
+          RAW_NULL_CHECK(buf);
+          if (dataConverToStr(buf, bufSize, pTagVal->tagType, pTagVal->pTagVal, pTagVal->nTagVal, NULL) !=
+              TSDB_CODE_SUCCESS) {
+            taosMemoryFree(buf);
+            goto end;
+          }
+          cJSON* colValue = cJSON_CreateString(buf);
+          RAW_NULL_CHECK(colValue);
+          RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colValue", colValue));
+          taosMemoryFree(buf);
+        }
+        cJSON* isNullCJson = cJSON_CreateBool(isNull);
+        RAW_NULL_CHECK(isNullCJson);
+        RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colValueNull", isNullCJson));
+        RAW_FALSE_CHECK(cJSON_AddItemToArray(tags, member));
+      }
+      RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tags", tags));
+      break;
+    }
+
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: {
       cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
       RAW_NULL_CHECK(colName);
@@ -775,6 +830,9 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
 
 end:
   uDebug("alter table return");
+  if (vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL) {
+    taosArrayDestroy(vAlterTbReq.pMultiTag);
+  }
   tDecoderClear(&decoder);
   *pJson = json;
 }

source/common/src/tmsg.c

@@ -10511,6 +10511,21 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
         TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pReq->pTagVal, pReq->nTagVal));
       }
       break;
+    case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL: {
+      int32_t nTags = taosArrayGetSize(pReq->pMultiTag);
+      TAOS_CHECK_EXIT(tEncodeI32v(pEncoder, nTags));
+      for (int32_t i = 0; i < nTags; i++) {
+        SMultiTagUpateVal *pTag = taosArrayGet(pReq->pMultiTag, i);
+        TAOS_CHECK_EXIT(tEncodeI32v(pEncoder, pTag->colId));
+        TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pTag->tagName));
+        TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTag->isNull));
+        TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTag->tagType));
+        if (!pTag->isNull) {
+          TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pTag->pTagVal, pTag->nTagVal));
+        }
+      }
+      break;
+    }
     case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
       TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pReq->updateTTL));
       if (pReq->updateTTL) {
@@ -10577,6 +10592,28 @@ static int32_t tDecodeSVAlterTbReqCommon(SDecoder *pDecoder, SVAlterTbReq *pReq)
         TAOS_CHECK_EXIT(tDecodeBinary(pDecoder, &pReq->pTagVal, &pReq->nTagVal));
       }
       break;
+    case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL: {
+      int32_t nTags;
+      TAOS_CHECK_EXIT(tDecodeI32v(pDecoder, &nTags));
+      pReq->pMultiTag = taosArrayInit(nTags, sizeof(SMultiTagUpateVal));
+      if (pReq->pMultiTag == NULL) {
+        TAOS_CHECK_EXIT(terrno);
+      }
+      for (int32_t i = 0; i < nTags; i++) {
+        SMultiTagUpateVal tag;
+        TAOS_CHECK_EXIT(tDecodeI32v(pDecoder, &tag.colId));
+        TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &tag.tagName));
+        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &tag.isNull));
+        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &tag.tagType));
+        if (!tag.isNull) {
+          TAOS_CHECK_EXIT(tDecodeBinary(pDecoder, &tag.pTagVal, &tag.nTagVal));
+        }
+        if (taosArrayPush(pReq->pMultiTag, &tag) == NULL) {
+          TAOS_CHECK_EXIT(terrno);
+        }
+      }
+      break;
+    }
     case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
       TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->updateTTL));
       if (pReq->updateTTL) {
@@ -10642,6 +10679,18 @@ _exit:
   return code;
 }
 
+void tfreeMultiTagUpateVal(void *val) {
+  SMultiTagUpateVal *pTag = val;
+  taosMemoryFree(pTag->tagName);
+  for (int i = 0; i < taosArrayGetSize(pTag->pTagArray); ++i) {
+    STagVal *p = (STagVal *)taosArrayGet(pTag->pTagArray, i);
+    if (IS_VAR_DATA_TYPE(p->type)) {
+      taosMemoryFreeClear(p->pData);
+    }
+  }
+
+  taosArrayDestroy(pTag->pTagArray);
+}
 int32_t tEncodeSVAlterTbRsp(SEncoder *pEncoder, const SVAlterTbRsp *pRsp) {
   int32_t code = 0;
   int32_t lino;

source/dnode/vnode/src/meta/metaTable.c

@@ -2011,6 +2011,255 @@ _err:
   return terrno != 0 ? terrno : TSDB_CODE_FAILED;
 }
 
+static int metaUpdateTableMultiTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
+  SMetaEntry  ctbEntry = {0};
+  SMetaEntry  stbEntry = {0};
+  void       *pVal = NULL;
+  int         nVal = 0;
+  int         ret;
+  int         c;
+  tb_uid_t    uid;
+  int64_t     oversion;
+  const void *pData = NULL;
+  int         nData = 0;
+  SHashObj   *pTagTable = NULL;
+
+  // search name index
+  ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal);
+  if (ret < 0) {
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
+  }
+
+  uid = *(tb_uid_t *)pVal;
+  tdbFree(pVal);
+  pVal = NULL;
+
+  // search uid index
+  TBC *pUidIdxc = NULL;
+
+  TAOS_CHECK_RETURN(tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL));
+  if (tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c) < 0) {
+    metaTrace("meta/table: failed to move to uid index, uid:%" PRId64, uid);
+  }
+  if (c != 0) {
+    tdbTbcClose(pUidIdxc);
+    metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c);
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
+  }
+
+  if (tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData) != 0) {
+    tdbTbcClose(pUidIdxc);
+    metaError("meta/table: failed to get uid index, uid:%" PRId64, uid);
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
+  }
+  oversion = ((SUidIdxVal *)pData)[0].version;
+
+  // search table.db
+  TBC     *pTbDbc = NULL;
+  SDecoder dc1 = {0};
+  SDecoder dc2 = {0};
+
+  /* get ctbEntry */
+  TAOS_CHECK_RETURN(tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL));
+  if (tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c) != 0) {
+    metaError("meta/table: failed to move to tb db, uid:%" PRId64, uid);
+  }
+  if (c != 0) {
+    tdbTbcClose(pUidIdxc);
+    tdbTbcClose(pTbDbc);
+    metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c);
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
+  }
+
+  if (tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData) != 0) {
+    metaError("meta/table: failed to get tb db, uid:%" PRId64, uid);
+    tdbTbcClose(pUidIdxc);
+    tdbTbcClose(pTbDbc);
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
+  }
+
+  if ((ctbEntry.pBuf = taosMemoryMalloc(nData)) == NULL) {
+    tdbTbcClose(pUidIdxc);
+    tdbTbcClose(pTbDbc);
+    return terrno;
+  }
+  memcpy(ctbEntry.pBuf, pData, nData);
+  tDecoderInit(&dc1, ctbEntry.pBuf, nData);
+  ret = metaDecodeEntry(&dc1, &ctbEntry);
+  if (ret < 0) {
+    terrno = ret;
+    goto _err;
+  }
+
+  /* get stbEntry*/
+  if (tdbTbGet(pMeta->pUidIdx, &ctbEntry.ctbEntry.suid, sizeof(tb_uid_t), &pVal, &nVal) != 0) {
+    metaError("meta/table: failed to get uid index, uid:%" PRId64, ctbEntry.ctbEntry.suid);
+  }
+  if (!pVal) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto _err;
+  }
+
+  if (tdbTbGet(pMeta->pTbDb, &((STbDbKey){.uid = ctbEntry.ctbEntry.suid, .version = ((SUidIdxVal *)pVal)[0].version}),
+               sizeof(STbDbKey), (void **)&stbEntry.pBuf, &nVal) != 0) {
+    metaError("meta/table: failed to get tb db, uid:%" PRId64, ctbEntry.ctbEntry.suid);
+  }
+  tdbFree(pVal);
+  tDecoderInit(&dc2, stbEntry.pBuf, nVal);
+  ret = metaDecodeEntry(&dc2, &stbEntry);
+  if (ret < 0) {
+    terrno = ret;
+    goto _err;
+  }
+
+  int32_t nTagVals = taosArrayGetSize(pAlterTbReq->pMultiTag);
+  pTagTable = taosHashInit(nTagVals, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  if (pTagTable == NULL) {
+    ret = terrno;
+    goto _err;
+  }
+
+  // remove duplicate tag name
+  for (int i = 0; i < nTagVals; i++) {
+    SMultiTagUpateVal *pTagVal = taosArrayGet(pAlterTbReq->pMultiTag, i);
+    ret = taosHashPut(pTagTable, pTagVal->tagName, strlen(pTagVal->tagName), pTagVal, sizeof(*pTagVal));
+    if (ret != 0) {
+      goto _err;
+    }
+  }
+
+  SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
+  SSchema        *pColumn = NULL;
+  int32_t         iCol = 0;
+  int32_t         count = 0;
+
+  for (;;) {
+    pColumn = NULL;
+
+    if (iCol >= pTagSchema->nCols) break;
+    pColumn = &pTagSchema->pSchema[iCol];
+    if (taosHashGet(pTagTable, pColumn->name, strlen(pColumn->name)) != NULL) {
+      count++;
+    }
+    iCol++;
+  }
+  if (count != taosHashGetSize(pTagTable)) {
+    terrno = TSDB_CODE_VND_COL_NOT_EXISTS;
+    goto _err;
+  }
+
+  ctbEntry.version = version;
+  if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) {
+    terrno = TSDB_CODE_VND_COL_NOT_EXISTS;
+    goto _err;
+  } else {
+    const STag *pOldTag = (const STag *)ctbEntry.ctbEntry.pTags;
+    STag       *pNewTag = NULL;
+    SArray     *pTagArray = taosArrayInit(pTagSchema->nCols, sizeof(STagVal));
+    if (!pTagArray) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto _err;
+    }
+    for (int32_t i = 0; i < pTagSchema->nCols; i++) {
+      SSchema           *pCol = &pTagSchema->pSchema[i];
+      SMultiTagUpateVal *pTagVal = taosHashGet(pTagTable, pCol->name, strlen(pCol->name));
+      if (pTagVal == NULL) {
+        STagVal val = {.cid = pCol->colId};
+        if (tTagGet(pOldTag, &val)) {
+          if (taosArrayPush(pTagArray, &val) == NULL) {
+            terrno = TSDB_CODE_OUT_OF_MEMORY;
+            taosArrayDestroy(pTagArray);
+            goto _err;
+          }
+        }
+      } else {
+        STagVal val = {0};
+        val.type = pCol->type;
+        val.cid = pCol->colId;
+        if (pTagVal->isNull) continue;
+
+        if (IS_VAR_DATA_TYPE(pCol->type)) {
+          val.pData = pTagVal->pTagVal;
+          val.nData = pTagVal->nTagVal;
+        } else {
+          memcpy(&val.i64, pTagVal->pTagVal, pTagVal->nTagVal);
+        }
+        if (taosArrayPush(pTagArray, &val) == NULL) {
+          terrno = TSDB_CODE_OUT_OF_MEMORY;
+          taosArrayDestroy(pTagArray);
+          goto _err;
+        }
+      }
+    }
+    if ((terrno = tTagNew(pTagArray, pTagSchema->version, false, &pNewTag)) < 0) {
+      taosArrayDestroy(pTagArray);
+      goto _err;
+    }
+    ctbEntry.ctbEntry.pTags = (uint8_t *)pNewTag;
+    taosArrayDestroy(pTagArray);
+  }
+
+  metaWLock(pMeta);
+
+  // save to table.db
+  if (metaSaveToTbDb(pMeta, &ctbEntry) < 0) {
+    metaError("meta/table: failed to save to tb db:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  // save to uid.idx
+  if (metaUpdateUidIdx(pMeta, &ctbEntry) < 0) {
+    metaError("meta/table: failed to update uid idx:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  if (metaUpdateTagIdx(pMeta, &ctbEntry) < 0) {
+    metaError("meta/table: failed to update tag idx:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  if (NULL == ctbEntry.ctbEntry.pTags) {
+    metaError("meta/table: null tags, update tag val failed.");
+    goto _err;
+  }
+
+  SCtbIdxKey ctbIdxKey = {.suid = ctbEntry.ctbEntry.suid, .uid = uid};
+  if (tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags,
+                  ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn) < 0) {
+    metaError("meta/table: failed to upsert ctb idx:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  if (metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid) < 0) {
+    metaError("meta/table: failed to clear uid cache:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  if (metaTbGroupCacheClear(pMeta, ctbEntry.ctbEntry.suid) < 0) {
+    metaError("meta/table: failed to clear group cache:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  if (metaUpdateChangeTime(pMeta, ctbEntry.uid, pAlterTbReq->ctimeMs) < 0) {
+    metaError("meta/table: failed to update change time:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid);
+  }
+
+  metaULock(pMeta);
+
+  tDecoderClear(&dc1);
+  tDecoderClear(&dc2);
+  taosMemoryFree((void *)ctbEntry.ctbEntry.pTags);
+  if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf);
+  if (stbEntry.pBuf) tdbFree(stbEntry.pBuf);
+  tdbTbcClose(pTbDbc);
+  tdbTbcClose(pUidIdxc);
+  taosHashCleanup(pTagTable);
+  return 0;
+
+_err:
+  tDecoderClear(&dc1);
+  tDecoderClear(&dc2);
+  if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf);
+  if (stbEntry.pBuf) tdbFree(stbEntry.pBuf);
+  tdbTbcClose(pTbDbc);
+  tdbTbcClose(pUidIdxc);
+  taosHashCleanup(pTagTable);
+  return -1;
+}
 static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
   SMetaEntry  ctbEntry = {0};
   SMetaEntry  stbEntry = {0};
@@ -2051,7 +2300,9 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   }
 
   if (tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData) != 0) {
+    tdbTbcClose(pUidIdxc);
     metaError("meta/table: failed to get uid index, uid:%" PRId64, uid);
+    return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
   }
   oversion = ((SUidIdxVal *)pData)[0].version;
 
@@ -2074,6 +2325,9 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
 
   if (tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData) != 0) {
     metaError("meta/table: failed to get tb db, uid:%" PRId64, uid);
+    tdbTbcClose(pUidIdxc);
+    tdbTbcClose(pTbDbc);
+    return terrno = TSDB_CODE_INVALID_MSG;
   }
 
   if ((ctbEntry.pBuf = taosMemoryMalloc(nData)) == NULL) {
@@ -2113,6 +2367,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
   SSchema        *pColumn = NULL;
   int32_t         iCol = 0;
+
   for (;;) {
     pColumn = NULL;
 
@@ -2736,6 +2991,9 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMeta
       return metaAlterTableColumn(pMeta, version, pReq, pMetaRsp);
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
       return metaUpdateTableTagVal(pMeta, version, pReq);
+    case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
+      return metaUpdateTableMultiTagVal(pMeta, version, pReq);
+      return terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
     case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
       return metaUpdateTableOptions(pMeta, version, pReq);
     case TSDB_ALTER_TABLE_ADD_TAG_INDEX:

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -145,8 +145,12 @@ static int32_t vnodePreProcessAlterTableMsg(SVnode *pVnode, SRpcMsg *pMsg) {
   SVAlterTbReq vAlterTbReq = {0};
   int64_t      ctimeMs = taosGetTimestampMs();
   if (tDecodeSVAlterTbReqSetCtime(&dc, &vAlterTbReq, ctimeMs) < 0) {
+    taosArrayDestroy(vAlterTbReq.pMultiTag);
+    vAlterTbReq.pMultiTag = NULL;
     goto _exit;
   }
+  taosArrayDestroy(vAlterTbReq.pMultiTag);
+  vAlterTbReq.pMultiTag = NULL;
 
   code = 0;
 
@@ -666,8 +670,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg
       }
     } break;
     case TDMT_VND_STREAM_TASK_RESET: {
-      if (pVnode->restored && vnodeIsLeader(pVnode) &&
+      if (pVnode->restored && vnodeIsLeader(pVnode) && (code = tqProcessTaskResetReq(pVnode->pTq, pMsg)) < 0) {
-           (code = tqProcessTaskResetReq(pVnode->pTq, pMsg)) < 0) {
         goto _err;
       }
 
@@ -1367,6 +1370,7 @@ static int32_t vnodeProcessAlterTbReq(SVnode *pVnode, int64_t ver, void *pReq, i
   }
 
 _exit:
+  taosArrayDestroy(vAlterTbReq.pMultiTag);
   tEncodeSize(tEncodeSVAlterTbRsp, &vAlterTbRsp, pRsp->contLen, ret);
   pRsp->pCont = rpcMallocCont(pRsp->contLen);
   tEncoderInit(&ec, pRsp->pCont, pRsp->contLen);

source/libs/nodes/src/nodesUtilFuncs.c

@@ -14,6 +14,7 @@
  */
 
 #include "cmdnodes.h"
+#include "functionMgt.h"
 #include "nodesUtil.h"
 #include "plannodes.h"
 #include "querynodes.h"
@@ -22,7 +23,6 @@
 #include "tdatablock.h"
 #include "thash.h"
 #include "tref.h"
-#include "functionMgt.h"
 
 typedef struct SNodeMemChunk {
   int32_t               availableSize;
@@ -59,12 +59,10 @@ char* getFullJoinTypeString(EJoinType type, EJoinSubType stype) {
       {"INNER", "INNER", "INNER", "INNER", "INNER", "INNER ANY", "INNER", "INNER"},
       {"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"},
       {"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"},
-    {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}
+      {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}};
-  };
   return joinFullType[type][stype];
 }
 
-
 int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
   if (NULL == *ppSrc) {
     return TSDB_CODE_SUCCESS;
@@ -74,14 +72,16 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
     *ppSrc = NULL;
     return TSDB_CODE_SUCCESS;
   }
-  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
+  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&
+      ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
     TSWAP(*ppDst, *ppSrc);
   }
   int32_t code = 0;
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) {
     SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst;
     if (pDst->condType == LOGIC_COND_TYPE_AND) {
-      if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
+      if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&
+          ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
         code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList);
         ((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL;
       } else {
@@ -115,7 +115,6 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
   return code;
 }
 
-
 static int32_t callocNodeChunk(SNodeAllocator* pAllocator, SNodeMemChunk** pOutChunk) {
   SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize);
   if (NULL == pNewChunk) {
@@ -155,7 +154,8 @@ static int32_t nodesCallocImpl(int32_t size, void** pOut) {
   void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize;
   g_pNodeAllocator->pCurrChunk->usedSize += size;
   *pOut = p;
-  return TSDB_CODE_SUCCESS;;
+  return TSDB_CODE_SUCCESS;
+  ;
 }
 
 static int32_t nodesCalloc(int32_t num, int32_t size, void** pOut) {
@@ -237,7 +237,8 @@ void nodesDestroyAllocatorSet() {
       refId = pAllocator->self;
       int32_t code = taosRemoveRef(g_allocatorReqRefPool, refId);
       if (TSDB_CODE_SUCCESS != code) {
-        nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%"PRId64, __func__, __LINE__, g_allocatorReqRefPool, refId);
+        nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__,
+                   g_allocatorReqRefPool, refId);
       }
       pAllocator = taosIterateRef(g_allocatorReqRefPool, refId);
     }
@@ -333,7 +334,8 @@ void nodesDestroyAllocator(int64_t allocatorId) {
 
   int32_t code = taosRemoveRef(g_allocatorReqRefPool, allocatorId);
   if (TSDB_CODE_SUCCESS != code) {
-    nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%"PRId64, __func__, __LINE__, g_allocatorReqRefPool, allocatorId);
+    nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__, g_allocatorReqRefPool,
+               allocatorId);
   }
 }
 
@@ -352,198 +354,290 @@ int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) {
   int32_t code = 0;
   switch (type) {
     case QUERY_NODE_COLUMN:
-      code = makeNode(type, sizeof(SColumnNode), &pNode); break;
+      code = makeNode(type, sizeof(SColumnNode), &pNode);
+      break;
     case QUERY_NODE_VALUE:
-      code = makeNode(type, sizeof(SValueNode), &pNode); break;
+      code = makeNode(type, sizeof(SValueNode), &pNode);
+      break;
     case QUERY_NODE_OPERATOR:
-      code = makeNode(type, sizeof(SOperatorNode), &pNode); break;
+      code = makeNode(type, sizeof(SOperatorNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_CONDITION:
-      code = makeNode(type, sizeof(SLogicConditionNode), &pNode); break;
+      code = makeNode(type, sizeof(SLogicConditionNode), &pNode);
+      break;
     case QUERY_NODE_FUNCTION:
-      code = makeNode(type, sizeof(SFunctionNode), &pNode); break;
+      code = makeNode(type, sizeof(SFunctionNode), &pNode);
+      break;
     case QUERY_NODE_REAL_TABLE:
-      code = makeNode(type, sizeof(SRealTableNode), &pNode); break;
+      code = makeNode(type, sizeof(SRealTableNode), &pNode);
+      break;
     case QUERY_NODE_TEMP_TABLE:
-      code = makeNode(type, sizeof(STempTableNode), &pNode); break;
+      code = makeNode(type, sizeof(STempTableNode), &pNode);
+      break;
     case QUERY_NODE_JOIN_TABLE:
-      code = makeNode(type, sizeof(SJoinTableNode), &pNode); break;
+      code = makeNode(type, sizeof(SJoinTableNode), &pNode);
+      break;
     case QUERY_NODE_GROUPING_SET:
-      code = makeNode(type, sizeof(SGroupingSetNode), &pNode); break;
+      code = makeNode(type, sizeof(SGroupingSetNode), &pNode);
+      break;
     case QUERY_NODE_ORDER_BY_EXPR:
-      code = makeNode(type, sizeof(SOrderByExprNode), &pNode); break;
+      code = makeNode(type, sizeof(SOrderByExprNode), &pNode);
+      break;
     case QUERY_NODE_LIMIT:
-      code = makeNode(type, sizeof(SLimitNode), &pNode); break;
+      code = makeNode(type, sizeof(SLimitNode), &pNode);
+      break;
     case QUERY_NODE_STATE_WINDOW:
-      code = makeNode(type, sizeof(SStateWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SStateWindowNode), &pNode);
+      break;
     case QUERY_NODE_SESSION_WINDOW:
-      code = makeNode(type, sizeof(SSessionWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SSessionWindowNode), &pNode);
+      break;
     case QUERY_NODE_INTERVAL_WINDOW:
-      code = makeNode(type, sizeof(SIntervalWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SIntervalWindowNode), &pNode);
+      break;
     case QUERY_NODE_NODE_LIST:
-      code = makeNode(type, sizeof(SNodeListNode), &pNode); break;
+      code = makeNode(type, sizeof(SNodeListNode), &pNode);
+      break;
     case QUERY_NODE_FILL:
-      code = makeNode(type, sizeof(SFillNode), &pNode); break;
+      code = makeNode(type, sizeof(SFillNode), &pNode);
+      break;
     case QUERY_NODE_RAW_EXPR:
-      code = makeNode(type, sizeof(SRawExprNode), &pNode); break;
+      code = makeNode(type, sizeof(SRawExprNode), &pNode);
+      break;
     case QUERY_NODE_TARGET:
-      code = makeNode(type, sizeof(STargetNode), &pNode); break;
+      code = makeNode(type, sizeof(STargetNode), &pNode);
+      break;
     case QUERY_NODE_DATABLOCK_DESC:
-      code = makeNode(type, sizeof(SDataBlockDescNode), &pNode); break;
+      code = makeNode(type, sizeof(SDataBlockDescNode), &pNode);
+      break;
     case QUERY_NODE_SLOT_DESC:
-      code = makeNode(type, sizeof(SSlotDescNode), &pNode); break;
+      code = makeNode(type, sizeof(SSlotDescNode), &pNode);
+      break;
     case QUERY_NODE_COLUMN_DEF:
-      code = makeNode(type, sizeof(SColumnDefNode), &pNode); break;
+      code = makeNode(type, sizeof(SColumnDefNode), &pNode);
+      break;
     case QUERY_NODE_DOWNSTREAM_SOURCE:
-      code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode); break;
+      code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode);
+      break;
     case QUERY_NODE_DATABASE_OPTIONS:
-      code = makeNode(type, sizeof(SDatabaseOptions), &pNode); break;
+      code = makeNode(type, sizeof(SDatabaseOptions), &pNode);
+      break;
     case QUERY_NODE_TABLE_OPTIONS:
-      code = makeNode(type, sizeof(STableOptions), &pNode); break;
+      code = makeNode(type, sizeof(STableOptions), &pNode);
+      break;
     case QUERY_NODE_COLUMN_OPTIONS:
-      code = makeNode(type, sizeof(SColumnOptions), &pNode); break;
+      code = makeNode(type, sizeof(SColumnOptions), &pNode);
+      break;
     case QUERY_NODE_INDEX_OPTIONS:
-      code = makeNode(type, sizeof(SIndexOptions), &pNode); break;
+      code = makeNode(type, sizeof(SIndexOptions), &pNode);
+      break;
     case QUERY_NODE_EXPLAIN_OPTIONS:
-      code = makeNode(type, sizeof(SExplainOptions), &pNode); break;
+      code = makeNode(type, sizeof(SExplainOptions), &pNode);
+      break;
     case QUERY_NODE_STREAM_OPTIONS:
-      code = makeNode(type, sizeof(SStreamOptions), &pNode); break;
+      code = makeNode(type, sizeof(SStreamOptions), &pNode);
+      break;
     case QUERY_NODE_LEFT_VALUE:
-      code = makeNode(type, sizeof(SLeftValueNode), &pNode); break;
+      code = makeNode(type, sizeof(SLeftValueNode), &pNode);
+      break;
     case QUERY_NODE_COLUMN_REF:
-      code = makeNode(type, sizeof(SColumnRefNode), &pNode); break;
+      code = makeNode(type, sizeof(SColumnRefNode), &pNode);
+      break;
     case QUERY_NODE_WHEN_THEN:
-      code = makeNode(type, sizeof(SWhenThenNode), &pNode); break;
+      code = makeNode(type, sizeof(SWhenThenNode), &pNode);
+      break;
     case QUERY_NODE_CASE_WHEN:
-      code = makeNode(type, sizeof(SCaseWhenNode), &pNode); break;
+      code = makeNode(type, sizeof(SCaseWhenNode), &pNode);
+      break;
     case QUERY_NODE_EVENT_WINDOW:
-      code = makeNode(type, sizeof(SEventWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SEventWindowNode), &pNode);
+      break;
     case QUERY_NODE_COUNT_WINDOW:
-      code = makeNode(type, sizeof(SCountWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SCountWindowNode), &pNode);
+      break;
     case QUERY_NODE_ANOMALY_WINDOW:
-      code = makeNode(type, sizeof(SAnomalyWindowNode), &pNode); break;
+      code = makeNode(type, sizeof(SAnomalyWindowNode), &pNode);
+      break;
     case QUERY_NODE_HINT:
-      code = makeNode(type, sizeof(SHintNode), &pNode); break;
+      code = makeNode(type, sizeof(SHintNode), &pNode);
+      break;
     case QUERY_NODE_VIEW:
-      code = makeNode(type, sizeof(SViewNode), &pNode); break;
+      code = makeNode(type, sizeof(SViewNode), &pNode);
+      break;
     case QUERY_NODE_WINDOW_OFFSET:
-      code = makeNode(type, sizeof(SWindowOffsetNode), &pNode); break;
+      code = makeNode(type, sizeof(SWindowOffsetNode), &pNode);
+      break;
     case QUERY_NODE_SET_OPERATOR:
-      code = makeNode(type, sizeof(SSetOperator), &pNode); break;
+      code = makeNode(type, sizeof(SSetOperator), &pNode);
+      break;
     case QUERY_NODE_SELECT_STMT:
-      code = makeNode(type, sizeof(SSelectStmt), &pNode); break;
+      code = makeNode(type, sizeof(SSelectStmt), &pNode);
+      break;
     case QUERY_NODE_VNODE_MODIFY_STMT:
-      code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode); break;
+      code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_DATABASE_STMT:
-      code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_DATABASE_STMT:
-      code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_DATABASE_STMT:
-      code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_FLUSH_DATABASE_STMT:
-      code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_TRIM_DATABASE_STMT:
-      code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_S3MIGRATE_DATABASE_STMT:
-      code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_TABLE_STMT:
-      code = makeNode(type, sizeof(SCreateTableStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateTableStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:
-      code = makeNode(type, sizeof(SCreateSubTableClause), &pNode); break;
+      code = makeNode(type, sizeof(SCreateSubTableClause), &pNode);
+      break;
     case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE:
-      code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode); break;
+      code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode);
+      break;
     case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
-      code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_TABLE_CLAUSE:
-      code = makeNode(type, sizeof(SDropTableClause), &pNode); break;
+      code = makeNode(type, sizeof(SDropTableClause), &pNode);
+      break;
     case QUERY_NODE_DROP_TABLE_STMT:
-      code = makeNode(type, sizeof(SDropTableStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropTableStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_SUPER_TABLE_STMT:
-      code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_TABLE_STMT:
     case QUERY_NODE_ALTER_SUPER_TABLE_STMT:
-      code = makeNode(type, sizeof(SAlterTableStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterTableStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_USER_STMT:
-      code = makeNode(type, sizeof(SCreateUserStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateUserStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_USER_STMT:
-      code = makeNode(type, sizeof(SAlterUserStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterUserStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_USER_STMT:
-      code = makeNode(type, sizeof(SDropUserStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropUserStmt), &pNode);
+      break;
     case QUERY_NODE_USE_DATABASE_STMT:
-      code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_DNODE_STMT:
-      code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_DNODE_STMT:
-      code = makeNode(type, sizeof(SDropDnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropDnodeStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_DNODE_STMT:
-      code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_ANODE_STMT:
-      code = makeNode(type, sizeof(SCreateAnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateAnodeStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_ANODE_STMT:
-      code = makeNode(type, sizeof(SDropAnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropAnodeStmt), &pNode);
+      break;
     case QUERY_NODE_UPDATE_ANODE_STMT:
-      code = makeNode(type, sizeof(SUpdateAnodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SUpdateAnodeStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_INDEX_STMT:
-      code = makeNode(type, sizeof(SCreateIndexStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateIndexStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_INDEX_STMT:
-      code = makeNode(type, sizeof(SDropIndexStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropIndexStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_QNODE_STMT:
     case QUERY_NODE_CREATE_BNODE_STMT:
     case QUERY_NODE_CREATE_SNODE_STMT:
     case QUERY_NODE_CREATE_MNODE_STMT:
-      code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_QNODE_STMT:
     case QUERY_NODE_DROP_BNODE_STMT:
     case QUERY_NODE_DROP_SNODE_STMT:
     case QUERY_NODE_DROP_MNODE_STMT:
-      code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_TOPIC_STMT:
-      code = makeNode(type, sizeof(SCreateTopicStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateTopicStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_TOPIC_STMT:
-      code = makeNode(type, sizeof(SDropTopicStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropTopicStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_CGROUP_STMT:
-      code = makeNode(type, sizeof(SDropCGroupStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropCGroupStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_LOCAL_STMT:
-      code = makeNode(type, sizeof(SAlterLocalStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterLocalStmt), &pNode);
+      break;
     case QUERY_NODE_EXPLAIN_STMT:
-      code = makeNode(type, sizeof(SExplainStmt), &pNode); break;
+      code = makeNode(type, sizeof(SExplainStmt), &pNode);
+      break;
     case QUERY_NODE_DESCRIBE_STMT:
-      code = makeNode(type, sizeof(SDescribeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDescribeStmt), &pNode);
+      break;
     case QUERY_NODE_RESET_QUERY_CACHE_STMT:
-      code = makeNode(type, sizeof(SNode), &pNode); break;
+      code = makeNode(type, sizeof(SNode), &pNode);
+      break;
     case QUERY_NODE_COMPACT_DATABASE_STMT:
-      code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_FUNCTION_STMT:
-      code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_FUNCTION_STMT:
-      code = makeNode(type, sizeof(SDropFunctionStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropFunctionStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_STREAM_STMT:
-      code = makeNode(type, sizeof(SCreateStreamStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateStreamStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_STREAM_STMT:
-      code = makeNode(type, sizeof(SDropStreamStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropStreamStmt), &pNode);
+      break;
     case QUERY_NODE_PAUSE_STREAM_STMT:
-      code = makeNode(type, sizeof(SPauseStreamStmt), &pNode); break;
+      code = makeNode(type, sizeof(SPauseStreamStmt), &pNode);
+      break;
     case QUERY_NODE_RESUME_STREAM_STMT:
-      code = makeNode(type, sizeof(SResumeStreamStmt), &pNode); break;
+      code = makeNode(type, sizeof(SResumeStreamStmt), &pNode);
+      break;
     case QUERY_NODE_BALANCE_VGROUP_STMT:
-      code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode); break;
+      code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode);
+      break;
     case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:
-      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break;
+      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);
+      break;
     case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:
-      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break;
+      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);
+      break;
     case QUERY_NODE_MERGE_VGROUP_STMT:
-      code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode); break;
+      code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode);
+      break;
     case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
-      code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode); break;
+      code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode);
+      break;
     case QUERY_NODE_SPLIT_VGROUP_STMT:
-      code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode); break;
+      code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode);
+      break;
     case QUERY_NODE_SYNCDB_STMT:
       break;
     case QUERY_NODE_GRANT_STMT:
-      code = makeNode(type, sizeof(SGrantStmt), &pNode); break;
+      code = makeNode(type, sizeof(SGrantStmt), &pNode);
+      break;
     case QUERY_NODE_REVOKE_STMT:
-      code = makeNode(type, sizeof(SRevokeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SRevokeStmt), &pNode);
+      break;
     case QUERY_NODE_ALTER_CLUSTER_STMT:
-      code = makeNode(type, sizeof(SAlterClusterStmt), &pNode); break;
+      code = makeNode(type, sizeof(SAlterClusterStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_DNODES_STMT:
     case QUERY_NODE_SHOW_MNODES_STMT:
     case QUERY_NODE_SHOW_MODULES_STMT:
@@ -583,191 +677,280 @@ int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) {
     case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:
     case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:
     case QUERY_NODE_SHOW_TSMAS_STMT:
-      code = makeNode(type, sizeof(SShowStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_TABLE_TAGS_STMT:
-      code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:
-      code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
-      code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_DB_ALIVE_STMT:
     case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:
-      code = makeNode(type, sizeof(SShowAliveStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowAliveStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
     case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
-      code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_CREATE_VIEW_STMT:
-      code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:
-      code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_COMPACTS_STMT:
-      code = makeNode(type, sizeof(SShowCompactsStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowCompactsStmt), &pNode);
+      break;
     case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:
-      code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode); break;
+      code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode);
+      break;
     case QUERY_NODE_KILL_QUERY_STMT:
-      code = makeNode(type, sizeof(SKillQueryStmt), &pNode); break;
+      code = makeNode(type, sizeof(SKillQueryStmt), &pNode);
+      break;
     case QUERY_NODE_KILL_TRANSACTION_STMT:
     case QUERY_NODE_KILL_CONNECTION_STMT:
     case QUERY_NODE_KILL_COMPACT_STMT:
-      code = makeNode(type, sizeof(SKillStmt), &pNode); break;
+      code = makeNode(type, sizeof(SKillStmt), &pNode);
+      break;
     case QUERY_NODE_DELETE_STMT:
-      code = makeNode(type, sizeof(SDeleteStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDeleteStmt), &pNode);
+      break;
     case QUERY_NODE_INSERT_STMT:
-      code = makeNode(type, sizeof(SInsertStmt), &pNode); break;
+      code = makeNode(type, sizeof(SInsertStmt), &pNode);
+      break;
     case QUERY_NODE_QUERY:
-      code = makeNode(type, sizeof(SQuery), &pNode); break;
+      code = makeNode(type, sizeof(SQuery), &pNode);
+      break;
     case QUERY_NODE_RESTORE_DNODE_STMT:
     case QUERY_NODE_RESTORE_QNODE_STMT:
     case QUERY_NODE_RESTORE_MNODE_STMT:
     case QUERY_NODE_RESTORE_VNODE_STMT:
-      code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode); break;
+      code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_VIEW_STMT:
-      code = makeNode(type, sizeof(SCreateViewStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateViewStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_VIEW_STMT:
-      code = makeNode(type, sizeof(SDropViewStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropViewStmt), &pNode);
+      break;
     case QUERY_NODE_CREATE_TSMA_STMT:
-      code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode); break;
+      code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode);
+      break;
     case QUERY_NODE_DROP_TSMA_STMT:
-      code = makeNode(type, sizeof(SDropTSMAStmt), &pNode); break;
+      code = makeNode(type, sizeof(SDropTSMAStmt), &pNode);
+      break;
     case QUERY_NODE_TSMA_OPTIONS:
-      code = makeNode(type, sizeof(STSMAOptions), &pNode); break;
+      code = makeNode(type, sizeof(STSMAOptions), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_SCAN:
-      code = makeNode(type, sizeof(SScanLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SScanLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_JOIN:
-      code = makeNode(type, sizeof(SJoinLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SJoinLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_AGG:
-      code = makeNode(type, sizeof(SAggLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SAggLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_PROJECT:
-      code = makeNode(type, sizeof(SProjectLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SProjectLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY:
-      code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
-      code = makeNode(type, sizeof(SExchangeLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SExchangeLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_MERGE:
-      code = makeNode(type, sizeof(SMergeLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SMergeLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_WINDOW:
-      code = makeNode(type, sizeof(SWindowLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SWindowLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_FILL:
-      code = makeNode(type, sizeof(SFillLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SFillLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_SORT:
-      code = makeNode(type, sizeof(SSortLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SSortLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_PARTITION:
-      code = makeNode(type, sizeof(SPartitionLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SPartitionLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC:
-      code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC:
-      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC:
-      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE:
-      code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL:
-      code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode);
+      break;
     case QUERY_NODE_LOGIC_SUBPLAN:
-      code = makeNode(type, sizeof(SLogicSubplan), &pNode); break;
+      code = makeNode(type, sizeof(SLogicSubplan), &pNode);
+      break;
     case QUERY_NODE_LOGIC_PLAN:
-      code = makeNode(type, sizeof(SQueryLogicPlan), &pNode); break;
+      code = makeNode(type, sizeof(SQueryLogicPlan), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
-      code = makeNode(type, sizeof(STagScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(STagScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
-      code = makeNode(type, sizeof(STableScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(STableScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
-      code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
-      code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
-      code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
-      code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
-      code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
-      code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN:
-      code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
-      code = makeNode(type, sizeof(SProjectPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SProjectPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:
-      code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:
-      code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:
-      code = makeNode(type, sizeof(SAggPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SAggPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:
-      code = makeNode(type, sizeof(SExchangePhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SExchangePhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE:
-      code = makeNode(type, sizeof(SMergePhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SMergePhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_SORT:
-      code = makeNode(type, sizeof(SSortPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SSortPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT:
-      code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:
-      code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:
-      code = makeNode(type, sizeof(SMergeIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SMergeIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:
-      code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
-      code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
-      code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
-      code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
-      code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
-      code = makeNode(type, sizeof(SFillPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SFillPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:
-      code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:
-      code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:
-      code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION:
-      code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:
-      code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE:
-      code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:
-      code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT:
-      code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:
-      code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY:
-      code = makeNode(type, sizeof(SAnomalyWindowPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SAnomalyWindowPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT:
-      code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_PARTITION:
-      code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION:
-      code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:
-      code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:
-      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC:
-      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode); break;
+      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
-      code = makeNode(type, sizeof(SDataDispatcherNode), &pNode); break;
+      code = makeNode(type, sizeof(SDataDispatcherNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
-      code = makeNode(type, sizeof(SDataInserterNode), &pNode); break;
+      code = makeNode(type, sizeof(SDataInserterNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
-      code = makeNode(type, sizeof(SQueryInserterNode), &pNode); break;
+      code = makeNode(type, sizeof(SQueryInserterNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_DELETE:
-      code = makeNode(type, sizeof(SDataDeleterNode), &pNode); break;
+      code = makeNode(type, sizeof(SDataDeleterNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:
-      code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:
-      code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_SUBPLAN:
-      code = makeNode(type, sizeof(SSubplan), &pNode); break;
+      code = makeNode(type, sizeof(SSubplan), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN:
-      code = makeNode(type, sizeof(SQueryPlan), &pNode); break;
+      code = makeNode(type, sizeof(SQueryPlan), &pNode);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERP_FUNC:
-      code = makeNode(type, sizeof(SStreamInterpFuncPhysiNode), &pNode); break;
+      code = makeNode(type, sizeof(SStreamInterpFuncPhysiNode), &pNode);
+      break;
     default:
       break;
   }
@@ -1174,6 +1357,15 @@ void nodesDestroyNode(SNode* pNode) {
       SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;
       nodesDestroyNode((SNode*)pStmt->pOptions);
       nodesDestroyNode((SNode*)pStmt->pVal);
+      if (pStmt->pNodeListTagValue != NULL) {
+        SNodeList* pNodeList = pStmt->pNodeListTagValue;
+        SNode*     pSubNode = NULL;
+        FOREACH(pSubNode, pNodeList) {
+          SAlterTableStmt* pSubAlterTable = (SAlterTableStmt*)pSubNode;
+          nodesDestroyNode((SNode*)pSubAlterTable->pOptions);
+          nodesDestroyNode((SNode*)pSubAlterTable->pVal);
+        }
+      }
       break;
     }
     case QUERY_NODE_CREATE_USER_STMT: {
@@ -1891,7 +2083,6 @@ int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) {
   return code;
 }
 
-
 int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) {
   if (NULL == *pTarget) {
     int32_t code = nodesMakeList(pTarget);
@@ -2350,7 +2541,8 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN
 static bool isCollectType(ECollectColType collectType, EColumnType colType) {
   return COLLECT_COL_TYPE_ALL == collectType
              ? true
-             : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType));
+             : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType
+                                                    : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType));
 }
 
 static EDealRes collectColumns(SNode* pNode, void* pContext) {
@@ -2370,7 +2562,9 @@ static EDealRes collectColumnsExt(SNode* pNode, void* pContext) {
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     SColumnNode* pCol = (SColumnNode*)pNode;
     if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&
-        (NULL == pCxt->pMultiTableAlias || NULL != (pCxt->pTableAlias = tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) {
+        (NULL == pCxt->pMultiTableAlias ||
+         NULL != (pCxt->pTableAlias =
+                      tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) {
       return doCollect(pCxt, pCol, pNode);
     }
   }
@@ -2382,7 +2576,7 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
   if (NULL == pSelect || NULL == pCols) {
     return TSDB_CODE_FAILED;
   }
-  SNodeList * pList = NULL;
+  SNodeList* pList = NULL;
   if (!*pCols) {
     int32_t code = nodesMakeList(&pList);
     if (TSDB_CODE_SUCCESS != code) {
@@ -2414,13 +2608,13 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias, ECollectColType type,
+int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias,
-                            SNodeList** pCols) {
+                               ECollectColType type, SNodeList** pCols) {
   if (NULL == pSelect || NULL == pCols) {
     return TSDB_CODE_FAILED;
   }
 
-  SNodeList * pList = NULL;
+  SNodeList* pList = NULL;
   if (!*pCols) {
     int32_t code = nodesMakeList(&pList);
     if (TSDB_CODE_SUCCESS != code) {
@@ -2458,7 +2652,7 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle
   if (NULL == pCols) {
     return TSDB_CODE_FAILED;
   }
-  SNodeList * pList = NULL;
+  SNodeList* pList = NULL;
   if (!*pCols) {
     int32_t code = nodesMakeList(&pList);
     if (TSDB_CODE_SUCCESS != code) {
@@ -2543,21 +2737,21 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len)
   return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;
 }
 
-int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs) {
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
+                                SNodeList* pFuncs) {
   if (NULL == pSelect || NULL == pFuncs) {
     return TSDB_CODE_FAILED;
   }
 
-  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
+  SCollectFuncsCxt cxt = {
-                          .classifier = classifier,
+      .errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .tableAlias = tableAlias, .pFuncs = pFuncs};
-                          .tableAlias = tableAlias,
-                          .pFuncs = pFuncs};
 
   nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
   return cxt.errCode;
 }
 
-int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) {
+int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
+                          SNodeList** pFuncs) {
   if (NULL == pSelect || NULL == pFuncs) {
     return TSDB_CODE_FAILED;
   }

source/libs/parser/inc/parAst.h

@@ -165,6 +165,7 @@ SNode*     createInterpTimeRange(SAstCreateContext* pCxt, SNode* pStart, SNode*
 SNode*     createInterpTimePoint(SAstCreateContext* pCxt, SNode* pPoint);
 SNode*     createWhenThenNode(SAstCreateContext* pCxt, SNode* pWhen, SNode* pThen);
 SNode*     createCaseWhenNode(SAstCreateContext* pCxt, SNode* pCase, SNodeList* pWhenThenList, SNode* pElse);
+SNode*     createAlterSingleTagColumnNode(SAstCreateContext* pCtx, SToken* token, SNode* pVal);
 
 SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere);
 SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList);
@@ -228,6 +229,7 @@ SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_
 SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pOldColName,
                                  SToken* pNewColName);
 SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken* pTagName, SNode* pVal);
+SNode* createAlterTableSetMultiTagValue(SAstCreateContext* pCxt, SNode* pRealTable, SNodeList* singleNode);
 SNode* setAlterSuperTableType(SNode* pStmt);
 SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
 SNode* setShowKind(SAstCreateContext* pCxt, SNode* pStmt, EShowKind showKind);

source/libs/parser/inc/sql.y

@@ -370,6 +370,7 @@ cmd ::= DROP STABLE with_opt(A) exists_opt(B) full_table_name(C).
 cmd ::= ALTER TABLE alter_table_clause(A).                                        { pCxt->pRootNode = A; }
 cmd ::= ALTER STABLE alter_table_clause(A).                                       { pCxt->pRootNode = setAlterSuperTableType(A); }
 
+
 alter_table_clause(A) ::= full_table_name(B) alter_table_options(C).              { A = createAlterTableModifyOptions(pCxt, B, C); }
 alter_table_clause(A) ::=
   full_table_name(B) ADD COLUMN column_name(C) type_name(D) column_options(E).                      { A = createAlterTableAddModifyColOptions2(pCxt, B, TSDB_ALTER_TABLE_ADD_COLUMN, &C, D, E); }
@@ -387,8 +388,16 @@ alter_table_clause(A) ::=
   full_table_name(B) MODIFY TAG column_name(C) type_name(D).                      { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &C, D); }
 alter_table_clause(A) ::=
   full_table_name(B) RENAME TAG column_name(C) column_name(D).                    { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &C, &D); }
+
+
+%type column_tag_value_list                                                              { SNodeList* }
+%destructor column_tag_value_list                                                        { nodesDestroyList($$); }
+column_tag_value(A) ::= column_name(C) NK_EQ tags_literal(D).                      { A = createAlterSingleTagColumnNode(pCxt, &C, D); }            
+column_tag_value_list(A) ::= column_tag_value(B).                                    { A = createNodeList(pCxt, B); }
+column_tag_value_list(A) ::= column_tag_value_list(B) NK_COMMA column_tag_value(C).      { A = addNodeToList(pCxt, B, C);}
+
 alter_table_clause(A) ::=
-  full_table_name(B) SET TAG column_name(C) NK_EQ tags_literal(D).                { A = createAlterTableSetTag(pCxt, B, &C, D); }
+  full_table_name(B) SET TAG column_tag_value_list(C).                             { A = createAlterTableSetMultiTagValue(pCxt, B, C); }
 
 %type multi_create_clause                                                         { SNodeList* }
 %destructor multi_create_clause                                                   { nodesDestroyList($$); }

source/libs/parser/src/parAstCreater.c

@@ -2541,6 +2541,20 @@ _err:
   return NULL;
 }
 
+SNode* createAlterSingleTagColumnNode(SAstCreateContext* pCtx, SToken* pTagName, SNode* pVal) {
+  CHECK_PARSER_STATUS(pCtx);
+  SAlterTableStmt* pStmt = NULL;
+  pCtx->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt);
+  CHECK_MAKE_NODE(pStmt);
+  pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pTagName);
+  pStmt->pVal = (SValueNode*)pVal;
+  pStmt->pNodeListTagValue = NULL;
+  return (SNode*)pStmt;
+_err:
+  return NULL;
+}
+
 SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken* pTagName, SNode* pVal) {
   CHECK_PARSER_STATUS(pCxt);
   CHECK_NAME(checkColumnName(pCxt, pTagName));
@@ -2557,6 +2571,19 @@ _err:
   return NULL;
 }
 
+SNode* createAlterTableSetMultiTagValue(SAstCreateContext* pCxt, SNode* pRealTable, SNodeList* pList) {
+  CHECK_PARSER_STATUS(pCxt);
+  SAlterTableStmt* pStmt = NULL;
+  pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt);
+
+  CHECK_MAKE_NODE(pStmt);
+  pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL;
+  pStmt->pNodeListTagValue = pList;
+  return createAlterTableStmtFinalize(pRealTable, pStmt);
+_err:
+  return NULL;
+}
+
 SNode* setAlterSuperTableType(SNode* pStmt) {
   if (!pStmt) return NULL;
   setNodeType(pStmt, QUERY_NODE_ALTER_SUPER_TABLE_STMT);

source/libs/parser/src/parAstParser.c

@@ -239,7 +239,8 @@ static EDealRes collectMetaKeyFromOperator(SCollectMetaKeyFromExprCxt* pCxt, SOp
   if (TSDB_CODE_SUCCESS != code) return DEAL_RES_CONTINUE;
   if (pTableName) {
     SSelectStmt* pSelect = (SSelectStmt*)pCxt->pComCxt->pStmt;
-    pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, ((SRealTableNode*)pSelect->pFromTable)->table.dbName, pTableName, AUTH_TYPE_READ);
+    pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, ((SRealTableNode*)pSelect->pFromTable)->table.dbName,
+                                                    pTableName, AUTH_TYPE_READ);
   }
 
   return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR;

source/libs/parser/src/parTranslater.c

@@ -97,6 +97,7 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = {
     .showType = QUERY_NODE_SHOW_DNODES_STMT,
     .pDbName = TSDB_INFORMATION_SCHEMA_DB,
     .pTableName = TSDB_INS_TABLE_DNODES,
+
     .numOfShowCols = 1,
     .pShowCols = {"*"}
   },
@@ -1853,7 +1854,7 @@ static bool clauseSupportAlias(ESqlClause clause) {
   return SQL_CLAUSE_GROUP_BY == clause || SQL_CLAUSE_PARTITION_BY == clause || SQL_CLAUSE_ORDER_BY == clause;
 }
 
-static EDealRes translateColumnInGroupByClause(STranslateContext* pCxt, SColumnNode** pCol, bool *translateAsAlias) {
+static EDealRes translateColumnInGroupByClause(STranslateContext* pCxt, SColumnNode** pCol, bool* translateAsAlias) {
   *translateAsAlias = false;
   // count(*)/first(*)/last(*) and so on
   if (0 == strcmp((*pCol)->colName, "*")) {
@@ -1876,9 +1877,8 @@ static EDealRes translateColumnInGroupByClause(STranslateContext* pCxt, SColumnN
   } else {
     bool found = false;
     res = translateColumnWithoutPrefix(pCxt, pCol);
-    if (!(*pCol)->node.asParam &&
+    if (!(*pCol)->node.asParam && res != DEAL_RES_CONTINUE && res != DEAL_RES_END &&
-        res != DEAL_RES_CONTINUE &&
+        pCxt->errCode != TSDB_CODE_PAR_AMBIGUOUS_COLUMN) {
-        res != DEAL_RES_END && pCxt->errCode != TSDB_CODE_PAR_AMBIGUOUS_COLUMN) {
       res = translateColumnUseAlias(pCxt, pCol, &found);
       *translateAsAlias = true;
     }
@@ -3321,9 +3321,11 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
     return TSDB_CODE_SUCCESS;
   }
 
-  if ((resultType == TSDB_DATA_TYPE_VARCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
+  if ((resultType == TSDB_DATA_TYPE_VARCHAR) &&
+      (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
     commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN);
-  } else if ((resultType == TSDB_DATA_TYPE_NCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
+  } else if ((resultType == TSDB_DATA_TYPE_NCHAR) &&
+             (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
     commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN * TSDB_NCHAR_SIZE);
   } else {
     commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]);
@@ -5480,7 +5482,7 @@ static EDealRes translateGroupPartitionByImpl(SNode** pNode, void* pContext) {
   int32_t                  code = TSDB_CODE_SUCCESS;
   STranslateContext*       pTransCxt = pCxt->pTranslateCxt;
   if (QUERY_NODE_VALUE == nodeType(*pNode)) {
-    SValueNode* pVal = (SValueNode*) *pNode;
+    SValueNode* pVal = (SValueNode*)*pNode;
     if (DEAL_RES_ERROR == translateValue(pTransCxt, pVal)) {
       return DEAL_RES_CONTINUE;
     }
@@ -5528,8 +5530,7 @@ static int32_t translateGroupByList(STranslateContext* pCxt, SSelectStmt* pSelec
   if (NULL == pSelect->pGroupByList) {
     return TSDB_CODE_SUCCESS;
   }
-  SReplaceGroupByAliasCxt cxt = {
+  SReplaceGroupByAliasCxt cxt = {.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
-      .pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
   nodesRewriteExprsPostOrder(pSelect->pGroupByList, translateGroupPartitionByImpl, &cxt);
 
   return pCxt->errCode;
@@ -5540,8 +5541,7 @@ static int32_t translatePartitionByList(STranslateContext* pCxt, SSelectStmt* pS
     return TSDB_CODE_SUCCESS;
   }
 
-  SReplaceGroupByAliasCxt cxt = {
+  SReplaceGroupByAliasCxt cxt = {.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
-      .pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
   nodesRewriteExprsPostOrder(pSelect->pPartitionByList, translateGroupPartitionByImpl, &cxt);
 
   return pCxt->errCode;
@@ -9495,7 +9495,8 @@ static int32_t checkAlterSuperTableBySchema(STranslateContext* pCxt, SAlterTable
 }
 
 static int32_t checkAlterSuperTable(STranslateContext* pCxt, SAlterTableStmt* pStmt) {
-  if (TSDB_ALTER_TABLE_UPDATE_TAG_VAL == pStmt->alterType) {
+  if (TSDB_ALTER_TABLE_UPDATE_TAG_VAL == pStmt->alterType ||
+      TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL == pStmt->alterType) {
     return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE,
                                    "Set tag value only available for child table");
   }
@@ -10521,7 +10522,8 @@ static void getSourceDatabase(SNode* pStmt, int32_t acctId, char* pDbFName) {
   (void)tNameGetFullDbName(&name, pDbFName);
 }
 
-static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len, char* defaultName[]) {
+static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len,
+                                                char* defaultName[]) {
   for (int32_t i = 0; defaultName[i] != NULL; i++) {
     if (NULL == taosHashGet(pUserAliasSet, defaultName[i], strlen(defaultName[i]))) {
       snprintf(aliasName, len, "%s", defaultName[i]);
@@ -10547,8 +10549,8 @@ static int32_t setColumnDefNodePrimaryKey(SColumnDefNode* pNode, bool isPk) {
   return code;
 }
 
-static int32_t addIrowTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSelectStmt* pSelect,
+static int32_t addIrowTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSelectStmt* pSelect, SHashObj* pUserAliasSet,
-                                                  SHashObj* pUserAliasSet, SNodeList* pCols, SCMCreateStreamReq* pReq) {
+                                                SNodeList* pCols, SCMCreateStreamReq* pReq) {
   SNode* pProj = nodesListGetNode(pSelect->pProjectionList, 0);
   if (!pSelect->hasInterpFunc ||
       (QUERY_NODE_FUNCTION == nodeType(pProj) && 0 == strcmp("_irowts", ((SFunctionNode*)pProj)->functionName))) {
@@ -10990,20 +10992,17 @@ static int32_t checkStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStm
 
   if (pStmt->pOptions->triggerType == STREAM_TRIGGER_FORCE_WINDOW_CLOSE) {
     if (pStmt->pOptions->fillHistory) {
-      return generateSyntaxErrMsgExt(
+      return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
-          &pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
                                      "When trigger was force window close, Stream unsupported Fill history");
     }
 
     if (pStmt->pOptions->ignoreExpired != 1) {
-      return generateSyntaxErrMsgExt(
+      return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
-          &pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
                                      "When trigger was force window close, Stream must not set  ignore expired 0");
     }
 
     if (pStmt->pOptions->ignoreUpdate != 1) {
-      return generateSyntaxErrMsgExt(
+      return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
-          &pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
                                      "When trigger was force window close, Stream must not set  ignore update 0");
     }
 
@@ -15183,24 +15182,88 @@ static int32_t rewriteDropSuperTable(STranslateContext* pCxt, SQuery* pQuery) {
   TAOS_RETURN(0);
 }
 
-static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
+static int32_t buildUpdateTagValReqImpl2(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
-                                    SVAlterTbReq* pReq) {
+                                         char* colName, SMultiTagUpateVal* pReq) {
-  SName   tbName = {0};
-  SArray* pTsmas = NULL;
   int32_t  code = TSDB_CODE_SUCCESS;
-  if (pCxt->pMetaCache) {
+  SSchema* pSchema = getTagSchema(pTableMeta, colName);
-    toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
+  if (NULL == pSchema) {
-    code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s", colName);
-    if (code != TSDB_CODE_SUCCESS) return code;
-    if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
   }
 
-  SSchema* pSchema = getTagSchema(pTableMeta, pStmt->colName);
+  pReq->tagName = taosStrdup(colName);
-  if (NULL == pSchema) {
+  if (NULL == pReq->tagName) {
-    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s",
+    TAOS_CHECK_GOTO(terrno, NULL, _err);
-                                   pStmt->colName);
   }
-  pReq->tagName = taosStrdup(pStmt->colName);
+
+  pReq->pTagArray = taosArrayInit(1, sizeof(STagVal));
+  if (NULL == pReq->pTagArray) {
+    TAOS_CHECK_GOTO(terrno, NULL, _err);
+  }
+  pReq->colId = pSchema->colId;
+  pReq->tagType = pSchema->type;
+
+  STag*       pTag = NULL;
+  SToken      token;
+  char        tokenBuf[TSDB_MAX_TAGS_LEN];
+  const char* tagStr = pStmt->pVal->literal;
+  NEXT_TOKEN_WITH_PREV(tagStr, token);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = checkAndTrimValue(&token, tokenBuf, &pCxt->msgBuf, pSchema->type);
+    if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) {
+      code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z);
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    code = parseTagValue(&pCxt->msgBuf, &tagStr, pTableMeta->tableInfo.precision, pSchema, &token, NULL,
+                         pReq->pTagArray, &pTag);
+    if (pSchema->type == TSDB_DATA_TYPE_JSON && token.type == TK_NULL && code == TSDB_CODE_SUCCESS) {
+      pReq->tagFree = true;
+    }
+  }
+  if (TSDB_CODE_SUCCESS == code && tagStr) {
+    NEXT_VALID_TOKEN(tagStr, token);
+    if (token.n != 0) {
+      code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z);
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    if (pSchema->type == TSDB_DATA_TYPE_JSON) {
+      code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values ", token.z);
+    } else {
+      STagVal* pTagVal = taosArrayGet(pReq->pTagArray, 0);
+      if (pTagVal) {
+        pReq->isNull = false;
+        if (IS_VAR_DATA_TYPE(pSchema->type)) {
+          pReq->nTagVal = pTagVal->nData;
+          pReq->pTagVal = pTagVal->pData;
+        } else {
+          pReq->nTagVal = pSchema->bytes;
+          pReq->pTagVal = (uint8_t*)&pTagVal->i64;
+        }
+      } else {
+        pReq->isNull = true;
+      }
+    }
+  }
+_err:
+  if (code != 0) {
+    taosArrayDestroy(pReq->pTagArray);
+    taosMemoryFree(pReq->tagName);
+  }
+  return code;
+}
+static int32_t buildUpdateTagValReqImpl(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
+                                        char* colName, SVAlterTbReq* pReq) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SSchema* pSchema = getTagSchema(pTableMeta, colName);
+  if (NULL == pSchema) {
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s", colName);
+  }
+
+  pReq->tagName = taosStrdup(colName);
   if (NULL == pReq->tagName) {
     return terrno;
   }
@@ -15261,6 +15324,82 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
 
   return code;
 }
+static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
+                                    SVAlterTbReq* pReq) {
+  SName   tbName = {0};
+  SArray* pTsmas = NULL;
+  int32_t code = TSDB_CODE_SUCCESS;
+  if (pCxt->pMetaCache) {
+    toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
+    code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
+    if (code != TSDB_CODE_SUCCESS) return code;
+    if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
+  }
+  return buildUpdateTagValReqImpl(pCxt, pStmt, pTableMeta, pStmt->colName, pReq);
+}
+
+static int32_t buildUpdateMultiTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
+                                         SVAlterTbReq* pReq) {
+  int32_t   code = TSDB_CODE_SUCCESS;
+  SName     tbName = {0};
+  SArray*   pTsmas = NULL;
+  SHashObj* pUnique = NULL;
+  if (pCxt->pMetaCache) {
+    toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
+    code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
+    if (code != TSDB_CODE_SUCCESS) return code;
+    if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
+  }
+  SNodeList* pNodeList = pStmt->pNodeListTagValue;
+  if (pNodeList == NULL) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+  }
+
+  int32_t nTagValues = pNodeList->length;
+  if (nTagValues == 1) {
+    SAlterTableStmt* head = (SAlterTableStmt*)pNodeList->pHead->pNode;
+    pReq->action = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
+    return buildUpdateTagValReqImpl(pCxt, head, pTableMeta, head->colName, pReq);
+  } else {
+    pReq->pMultiTag = taosArrayInit(nTagValues, sizeof(SMultiTagUpateVal));
+    if (pReq->pMultiTag == NULL) {
+      return terrno;
+    }
+
+    pUnique = taosHashInit(nTagValues, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+    if (pUnique == NULL) {
+      TAOS_CHECK_GOTO(terrno, NULL, _err);
+    }
+
+    SAlterTableStmt* pTagStmt = NULL;
+    SNode*           pNode = NULL;
+    int8_t           dummpy = 0;
+    FOREACH(pNode, pNodeList) {
+      SMultiTagUpateVal val = {0};
+      pTagStmt = (SAlterTableStmt*)pNode;
+
+      SMultiTagUpateVal* p = taosHashGet(pUnique, pTagStmt->colName, strlen(pTagStmt->colName));
+      if (p) {
+        code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_DUPLICATED_COLUMN);
+        TAOS_CHECK_GOTO(code, NULL, _err);
+      }
+
+      code = taosHashPut(pUnique, pTagStmt->colName, strlen(pTagStmt->colName), &dummpy, sizeof(dummpy));
+      TAOS_CHECK_GOTO(code, NULL, _err);
+
+      code = buildUpdateTagValReqImpl2(pCxt, pTagStmt, pTableMeta, pTagStmt->colName, &val);
+      TAOS_CHECK_GOTO(code, NULL, _err);
+
+      if (taosArrayPush(pReq->pMultiTag, &val) == NULL) {
+        tfreeMultiTagUpateVal((void*)&val);
+        TAOS_CHECK_GOTO(terrno, NULL, _err);
+      }
+    }
+  }
+_err:
+  taosHashCleanup(pUnique);
+  return code;
+}
 
 static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
                               SVAlterTbReq* pReq) {
@@ -15449,6 +15588,8 @@ static int32_t buildAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pStmt,
     case TSDB_ALTER_TABLE_UPDATE_TAG_NAME:
     case TSDB_ALTER_TABLE_UPDATE_TAG_BYTES:
       return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+    case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
+      return buildUpdateMultiTagValReq(pCxt, pStmt, pTableMeta, pReq);
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
       return buildUpdateTagValReq(pCxt, pStmt, pTableMeta, pReq);
     case TSDB_ALTER_TABLE_ADD_COLUMN:
@@ -15550,6 +15691,10 @@ static void destoryAlterTbReq(SVAlterTbReq* pReq) {
       taosMemoryFreeClear(p->pData);
     }
   }
+  if (pReq->action == TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL) {
+    taosArrayDestroyEx(pReq->pMultiTag, tfreeMultiTagUpateVal);
+  }
+
   taosArrayDestroy(pReq->pTagArray);
   if (pReq->tagFree) tTagFree((STag*)pReq->pTagVal);
 }

tests/parallel_test/cases.task

@@ -1582,6 +1582,7 @@
 ,,y,script,./test.sh -f tsim/tag/tinyint.sim
 ,,y,script,./test.sh -f tsim/tag/drop_tag.sim
 ,,y,script,./test.sh -f tsim/tag/tbNameIn.sim
+,,y,script,./test.sh -f tsim/tag/change_multi_tag.sim
 ,,y,script,./test.sh -f tmp/monitor.sim
 ,,y,script,./test.sh -f tsim/tagindex/add_index.sim
 ,,n,script,./test.sh -f tsim/tagindex/sma_and_tag_index.sim

tests/script/tsim/tag/change_multi_tag.sim

@@ -0,0 +1,205 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+print ======================== dnode1 start
+
+$dbPrefix = ta_ad_db
+$tbPrefix = ta_ad_tb
+$mtPrefix = ta_ad_mt
+$tbNum = 10
+$rowNum = 20
+$totalNum = 200
+
+print =============== step1
+$i = 0
+$db = $dbPrefix . $i
+
+sql create database $db
+sql use $db
+
+print =============== step2
+$j = 3
+$i = 2
+$mt = $mtPrefix . $i
+$tb = $tbPrefix . $i
+$tbj = $tbPrefix . $j
+$ntable = tb_normal_table
+
+sql create table $mt (ts timestamp, tbcol int) TAGS(tagCol1 bool, tagCol2 tinyint, tagCol3 smallint, tagCol4 int, tagCol5 bigint, tagCol6 nchar(10), tagCol7 binary(8))
+sql create table $tb using $mt tags( 1, 2, 3, 5,7, "test", "test")
+sql create table $tbj using $mt tags( 2, 3, 4, 6,8, "testj", "testj")
+sql create table $ntable (ts timestamp, f int)
+
+sql insert into $tb values(now, 1)
+sql insert into $tb values(now, 1)
+sql_error alter table $mt set tag tgcol1 = 1,tagcol2 = 2, tag3 = 4 # set tag value on supertable
+sql_error alter table $ntable set tag f = 10  # set normal table value
+sql_error alter table $tbj set tag tagCol1=1,tagCol1 = 2 # dumplicate tag name
+sql_error alter table $tbj set tag tagCol1=1,tagCol1 = 2 # not exist tag
+sql_error alter table $tbj set tag tagCol1 = 1, tagCol5="xxxxxxxxxxxxxxxx" 
+sql_error alter table $tbj set tag tagCol1 = 1, tagCol5="xxxxxxxxxxxxxxxx", tagCol7="yyyyyyyyyyyyyyyyyyyyyyyyy" 
+sql_error alter table $tbj set tag tagCol1=1,tagCol5=10, tagCol1=3
+sql_error alter table $tbj set tag tagCol5="xxxx"
+sql alter table $tbj set tag tagCol1 = 100, tagCol2 = 100 
+
+sql select * from $mt where tagCol2 = 100
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol1 = 1
+if $rows != 2  then
+  return -1
+endi
+
+sql alter table $tbj set tag tagCol1=true,tagCol2=-1,tagcol3=-10, tagcol4=-100,tagcol5=-1000,tagCol6="empty",tagCol7="empty1"
+sql alter table $tb set tag tagCol1=0
+
+sql select * from $mt where tagCol1 = true 
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol2 = -1 
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol3 = -10 
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol4 = -100 
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol5 = -1000 
+if $rows != 0  then
+  return -1
+endi
+
+
+sql select * from $mt where tagCol6 = "empty" 
+if $rows != 0  then
+  return -1
+endi
+
+sql select * from $mt where tagCol6 = "empty1" 
+if $rows != 0  then
+  return -1
+endi
+
+sql insert into $tbj values (now, 1)
+
+sql select * from $mt where tagCol1 = true 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol2 = -1 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol3 = -10 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol4 = -100 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol5 = -1000 
+if $rows != 1  then
+  return -1
+endi
+
+
+sql select * from $mt where tagCol6 = "empty" 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol7 = "empty1" 
+if $rows != 1  then
+  return -1
+endi
+
+sql alter table $tbj set tag tagCol1=true
+sql alter table $tb set tag tagCol1=true
+
+sql select * from $mt where tagCol1 = true 
+if $rows != 3  then
+  return -1
+endi
+
+sql alter table $tb set tag tagCol1=false
+
+sql alter table $tbj set tag tagCol1=true,tagCol2=-10,tagcol3=-100, tagcol4=-1000,tagcol5=-10000,tagCol6="empty1",tagCol7="empty2"
+
+sql select * from $mt where tagCol1 = true 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol2 = -10 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol3 = -100 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol4 = -1000 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol5 = -10000 
+if $rows != 1  then
+  return -1
+endi
+
+
+sql select * from $mt where tagCol6 = "empty1" 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol7 = "empty2" 
+if $rows != 1  then
+  return -1
+endi
+
+sql alter table $tbj set tag tagCol1=true,tagCol2=-10,tagcol3=-100, tagcol4=-1000,tagcol5=NULL,tagCol6=NULL,tagCol7=NULL
+
+sql alter table $mt drop tag tagCol7
+sql alter table $mt drop tag tagCol3
+
+sql alter table $mt add tag tagCol8 int
+
+sql_error alter table $tbj set tag tagCol1=true,tagCol2=-10,tagcol3=-100, tagcol4=-1000,tagcol5=NULL,tagCol6=NULL,tagCol7=NULL
+sql_error alter table $tbj set tag tagCol1=true,tagCol2=-10,tagcol3=-100, tagcol4=-1000,tagcol5=NULL,tagCol6=NULL,tagCol7=NULL
+
+sql alter table $tbj set tag tagCol8 = 8
+
+sql select * from $mt where tagCol4 = -1000 
+if $rows != 1  then
+  return -1
+endi
+
+sql select * from $mt where tagCol8 = 8 
+if $rows != 1  then
+  return -1
+endi
+
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/system-test/0-others/empty_identifier.py

@@ -145,7 +145,6 @@ class TDTestCase:
                 'select * from ``',
                 'alter table meters add column `` int',
                 'alter table meters drop column ``',
-                'alter table t0 set tag `` = ""',
                 'alter stable meters add tag `` int',
                 'alter stable meters rename tag cc ``',
                 'alter stable meters drop tag ``',