diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 70e76517c6e1d8a30658b15ff053cc0632fe8a8c..9cdd2de7e5610d91f42f4af00192ec3d5eebb0b6 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -111,8 +111,8 @@ typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_MAX,
 } EShowType;
 
-#define TSDB_ALTER_TABLE_ADD_TAG_COLUMN 1
-#define TSDB_ALTER_TABLE_DROP_TAG_COLUMN 2
+#define TSDB_ALTER_TABLE_ADD_TAG 1
+#define TSDB_ALTER_TABLE_DROP_TAG 2
 #define TSDB_ALTER_TABLE_UPDATE_TAG_NAME 3
 #define TSDB_ALTER_TABLE_UPDATE_TAG_VAL 4
 
@@ -1198,8 +1198,8 @@ typedef struct {
 
 int32_t tSerializeSVCreateTbBatchReq(void** buf, SVCreateTbBatchReq* pReq);
 void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pReq);
-int32_t tSerializeSVCreateTbBatchReqp(void** buf, SVCreateTbBatchReq* pRsp);
-void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pRsp);
+int32_t tSerializeSVCreateTbBatchRsp(void** buf, SVCreateTbBatchRsp* pRsp);
+void*   tDeserializeSVCreateTbBatchRsp(void* buf, SVCreateTbBatchRsp* pRsp);
 
 typedef struct {
   uint64_t ver;
@@ -1209,7 +1209,6 @@ typedef struct {
 } SVDropTbReq;
 
 typedef struct {
-  uint64_t ver;
 } SVDropTbRsp;
 
 int32_t tSerializeSVDropTbReq(void** buf, SVDropTbReq* pReq);
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index ea8bbb1231a229d6c374a799bfcaa61cf1865da5..c6f0c759afac70e94e6f0727e0f2c7f773697876 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -223,10 +223,10 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_STB_OPTION        TAOS_DEF_ERROR_CODE(0, 0x03A4)
 #define TSDB_CODE_MND_STB_OPTION_UNCHNAGED      TAOS_DEF_ERROR_CODE(0, 0x03A5)
 #define TSDB_CODE_MND_TOO_MANY_TAGS             TAOS_DEF_ERROR_CODE(0, 0x03A6)
-#define TSDB_CODE_MND_TAG_ALREAY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03A7)
+#define TSDB_CODE_MND_TAG_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x03A7)
 #define TSDB_CODE_MND_TAG_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03A8)
 #define TSDB_CODE_MND_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x03A9)
-#define TSDB_CODE_MND_COLUMN_ALREAY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03AA)
+#define TSDB_CODE_MND_COLUMN_ALREADY_EXIST      TAOS_DEF_ERROR_CODE(0, 0x03AA)
 #define TSDB_CODE_MND_COLUMN_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03AB)
 #define TSDB_CODE_MND_INVALID_ROW_BYTES         TAOS_DEF_ERROR_CODE(0, 0x03AC)
 #define TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC  TAOS_DEF_ERROR_CODE(0, 0x03AD)
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index e45b61554c0ba434ee482a702446d65aeb2a07cf..6f094b20f805664d965a6e9b0cd3e4c429c573ce 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -27,7 +27,7 @@
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
-int tInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
+int32_t tInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
   if (pMsg == NULL) {
     terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
     return -1;
@@ -44,7 +44,7 @@ int tInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
   return 0;
 }
 
-int tGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
+int32_t tGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
   if (pIter->len == 0) {
     pIter->len += sizeof(SSubmitMsg);
   } else {
@@ -63,7 +63,7 @@ int tGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
   return 0;
 }
 
-int tInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
+int32_t tInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
   if (pBlock->dataLen <= 0) return -1;
   pIter->totalLen = pBlock->dataLen;
   pIter->len = 0;
@@ -85,14 +85,14 @@ SMemRow tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
   }
 }
 
-int tSerializeSClientHbReq(void **buf, const SClientHbReq *pReq) {
-  int tlen = 0;
+int32_t tSerializeSClientHbReq(void **buf, const SClientHbReq *pReq) {
+  int32_t tlen = 0;
   tlen += taosEncodeSClientHbKey(buf, &pReq->connKey);
 
   int32_t kvNum = taosHashGetSize(pReq->info);
   tlen += taosEncodeFixedI32(buf, kvNum);
-  SKv *kv;
-  void* pIter = taosHashIterate(pReq->info, NULL);
+  SKv  *kv;
+  void *pIter = taosHashIterate(pReq->info, NULL);
   while (pIter != NULL) {
     kv = pIter;
     tlen += taosEncodeSKv(buf, kv);
@@ -111,7 +111,7 @@ void *tDeserializeSClientHbReq(void *buf, SClientHbReq *pReq) {
   if (pReq->info == NULL) {
     pReq->info = taosHashInit(kvNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   }
-  for(int i = 0; i < kvNum; i++) {
+  for (int32_t i = 0; i < kvNum; i++) {
     SKv kv;
     buf = taosDecodeSKv(buf, &kv);
     taosHashPut(pReq->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
@@ -120,54 +120,55 @@ void *tDeserializeSClientHbReq(void *buf, SClientHbReq *pReq) {
   return buf;
 }
 
-int   tSerializeSClientHbRsp(void** buf, const SClientHbRsp* pRsp) {
-  int tlen = 0;
+int32_t tSerializeSClientHbRsp(void **buf, const SClientHbRsp *pRsp) {
+  int32_t tlen = 0;
   int32_t kvNum = taosArrayGetSize(pRsp->info);
   tlen += taosEncodeSClientHbKey(buf, &pRsp->connKey);
   tlen += taosEncodeFixedI32(buf, pRsp->status);
   tlen += taosEncodeFixedI32(buf, kvNum);
-  for (int i = 0; i < kvNum; i++) {
+  for (int32_t i = 0; i < kvNum; i++) {
     SKv *kv = (SKv *)taosArrayGet(pRsp->info, i);
     tlen += taosEncodeSKv(buf, kv);
   }
   return tlen;
 }
-void* tDeserializeSClientHbRsp(void* buf, SClientHbRsp* pRsp) {
+
+void *tDeserializeSClientHbRsp(void *buf, SClientHbRsp *pRsp) {
   int32_t kvNum = 0;
   buf = taosDecodeSClientHbKey(buf, &pRsp->connKey);
   buf = taosDecodeFixedI32(buf, &pRsp->status);
   buf = taosDecodeFixedI32(buf, &kvNum);
   pRsp->info = taosArrayInit(kvNum, sizeof(SKv));
-  for (int i = 0; i < kvNum; i++) {
+  for (int32_t i = 0; i < kvNum; i++) {
     SKv kv = {0};
     buf = taosDecodeSKv(buf, &kv);
     taosArrayPush(pRsp->info, &kv);
   }
-  
+
   return buf;
 }
 
-int   tSerializeSClientHbBatchReq(void** buf, const SClientHbBatchReq* pBatchReq) {
-  int tlen = 0;
+int32_t tSerializeSClientHbBatchReq(void **buf, const SClientHbBatchReq *pBatchReq) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI64(buf, pBatchReq->reqId);
   int32_t reqNum = taosArrayGetSize(pBatchReq->reqs);
-  tlen += taosEncodeFixedI32(buf, reqNum); 
-  for (int i = 0; i < reqNum; i++) {
-    SClientHbReq* pReq = taosArrayGet(pBatchReq->reqs, i);
+  tlen += taosEncodeFixedI32(buf, reqNum);
+  for (int32_t i = 0; i < reqNum; i++) {
+    SClientHbReq *pReq = taosArrayGet(pBatchReq->reqs, i);
     tlen += tSerializeSClientHbReq(buf, pReq);
   }
   return tlen;
 }
 
-void* tDeserializeSClientHbBatchReq(void* buf, SClientHbBatchReq* pBatchReq) {
+void *tDeserializeSClientHbBatchReq(void *buf, SClientHbBatchReq *pBatchReq) {
   buf = taosDecodeFixedI64(buf, &pBatchReq->reqId);
   if (pBatchReq->reqs == NULL) {
     pBatchReq->reqs = taosArrayInit(0, sizeof(SClientHbReq));
   }
- 
+
   int32_t reqNum;
   buf = taosDecodeFixedI32(buf, &reqNum);
-  for (int i = 0; i < reqNum; i++) {
+  for (int32_t i = 0; i < reqNum; i++) {
     SClientHbReq req = {0};
     buf = tDeserializeSClientHbReq(buf, &req);
     taosArrayPush(pBatchReq->reqs, &req);
@@ -175,31 +176,31 @@ void* tDeserializeSClientHbBatchReq(void* buf, SClientHbBatchReq* pBatchReq) {
   return buf;
 }
 
-int   tSerializeSClientHbBatchRsp(void** buf, const SClientHbBatchRsp* pBatchRsp) {
-  int tlen = 0;
+int32_t tSerializeSClientHbBatchRsp(void **buf, const SClientHbBatchRsp *pBatchRsp) {
+  int32_t tlen = 0;
   int32_t sz = taosArrayGetSize(pBatchRsp->rsps);
   tlen += taosEncodeFixedI32(buf, sz);
-  for (int i = 0; i < sz; i++) {
-    SClientHbRsp* pRsp = taosArrayGet(pBatchRsp->rsps, i);
+  for (int32_t i = 0; i < sz; i++) {
+    SClientHbRsp *pRsp = taosArrayGet(pBatchRsp->rsps, i);
     tlen += tSerializeSClientHbRsp(buf, pRsp);
   }
   return tlen;
 }
 
-void* tDeserializeSClientHbBatchRsp(void* buf, SClientHbBatchRsp* pBatchRsp) {
+void *tDeserializeSClientHbBatchRsp(void *buf, SClientHbBatchRsp *pBatchRsp) {
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
   pBatchRsp->rsps = taosArrayInit(sz, sizeof(SClientHbRsp));
-  for (int i = 0; i < sz; i++) {
+  for (int32_t i = 0; i < sz; i++) {
     SClientHbRsp rsp = {0};
-    buf = tDeserializeSClientHbRsp(buf, &rsp); 
+    buf = tDeserializeSClientHbRsp(buf, &rsp);
     taosArrayPush(pBatchRsp->rsps, &rsp);
   }
   return buf;
 }
 
-int tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
-  int tlen = 0;
+int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
+  int32_t tlen = 0;
 
   tlen += taosEncodeFixedU64(buf, pReq->ver);
   tlen += taosEncodeString(buf, pReq->name);
@@ -293,8 +294,8 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
   return buf;
 }
 
-int tSerializeSVCreateTbBatchReq(void **buf, SVCreateTbBatchReq *pReq) {
-  int tlen = 0;
+int32_t tSerializeSVCreateTbBatchReq(void **buf, SVCreateTbBatchReq *pReq) {
+  int32_t tlen = 0;
 
   tlen += taosEncodeFixedU64(buf, pReq->ver);
   tlen += taosEncodeFixedU32(buf, taosArrayGetSize(pReq->pArray));
@@ -322,7 +323,7 @@ void *tDeserializeSVCreateTbBatchReq(void *buf, SVCreateTbBatchReq *pReq) {
 }
 
 int32_t tSerializeSVDropTbReq(void **buf, SVDropTbReq *pReq) {
-  int tlen = 0;
+  int32_t tlen = 0;
   tlen += taosEncodeFixedU64(buf, pReq->ver);
   tlen += taosEncodeString(buf, pReq->name);
   tlen += taosEncodeFixedU8(buf, pReq->type);
diff --git a/source/dnode/mgmt/impl/test/vnode/vnode.cpp b/source/dnode/mgmt/impl/test/vnode/vnode.cpp
index 9451608653e1a05eb27ed0e6d2852fb1ebcd9de6..380a837c58312a5be3a10241bddb32bb4e9d18b0 100644
--- a/source/dnode/mgmt/impl/test/vnode/vnode.cpp
+++ b/source/dnode/mgmt/impl/test/vnode/vnode.cpp
@@ -108,7 +108,7 @@ TEST_F(DndTestVnode, 01_Create_Vnode) {
   }
 }
 
-TEST_F(DndTestVnode, 02_ALTER_Vnode) {
+TEST_F(DndTestVnode, 02_Alter_Vnode) {
   for (int i = 0; i < 3; ++i) {
     int32_t contLen = sizeof(SAlterVnodeReq);
 
@@ -219,7 +219,7 @@ TEST_F(DndTestVnode, 03_Create_Stb) {
   }
 }
 
-TEST_F(DndTestVnode, 04_ALTER_Stb) {
+TEST_F(DndTestVnode, 04_Alter_Stb) {
   for (int i = 0; i < 1; ++i) {
     SVCreateTbReq req = {0};
     req.ver = 0;
@@ -310,7 +310,7 @@ TEST_F(DndTestVnode, 05_DROP_Stb) {
   }
 }
 
-TEST_F(DndTestVnode, 06_DROP_Vnode) {
+TEST_F(DndTestVnode, 06_Drop_Vnode) {
   for (int i = 0; i < 3; ++i) {
     int32_t contLen = sizeof(SDropVnodeReq);
 
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 006abcd8e2e2282a6c7fe9fd7e58cb5a39059d78..4bfe67c2c5da052e36eca0c804a7388b18b2fe01 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -652,12 +652,12 @@ static int32_t mndAddSuperTableTag(const SStbObj *pOld, SStbObj *pNew, const SSc
 
   for (int32_t i = 0; i < ntags; i++) {
     if (mndFindSuperTableColumnIndex(pOld, pSchemas[i].name) > 0) {
-      terrno = TSDB_CODE_MND_TAG_ALREAY_EXIST;
+      terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
       return -1;
     }
 
     if (mndFindSuperTableTagIndex(pOld, pSchemas[i].name) > 0) {
-      terrno = TSDB_CODE_MND_COLUMN_ALREAY_EXIST;
+      terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
       return -1;
     }
   }
@@ -692,6 +692,7 @@ static int32_t mndDropSuperTableTag(const SStbObj *pOld, SStbObj *pNew, const ch
   }
 
   memmove(pNew->pTags + tag, pNew->pTags + tag + 1, sizeof(SSchema) * (pNew->numOfTags - tag - 1));
+  pNew->numOfTags--;
 
   pNew->version++;
   mDebug("stb:%s, start to drop tag %s", pNew->name, tagName);
@@ -706,13 +707,12 @@ static int32_t mndAlterStbTagName(const SStbObj *pOld, SStbObj *pNew, const char
   }
 
   if (mndFindSuperTableTagIndex(pOld, newTagName) >= 0) {
-    terrno = TSDB_CODE_MND_TAG_ALREAY_EXIST;
+    terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
     return -1;
   }
 
-  int32_t len = (int32_t)strlen(newTagName);
-  if (len >= TSDB_COL_NAME_LEN) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
+  if (mndFindSuperTableColumnIndex(pOld, newTagName) >= 0) {
+    terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
     return -1;
   }
 
@@ -765,12 +765,12 @@ static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, const
 
   for (int32_t i = 0; i < ncols; i++) {
     if (mndFindSuperTableColumnIndex(pOld, pSchemas[i].name) > 0) {
-      terrno = TSDB_CODE_MND_TAG_ALREAY_EXIST;
+      terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
       return -1;
     }
 
     if (mndFindSuperTableTagIndex(pOld, pSchemas[i].name) > 0) {
-      terrno = TSDB_CODE_MND_COLUMN_ALREAY_EXIST;
+      terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
       return -1;
     }
   }
@@ -805,6 +805,7 @@ static int32_t mndDropSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, const
   }
 
   memmove(pNew->pColumns + col, pNew->pColumns + col + 1, sizeof(SSchema) * (pNew->numOfColumns - col - 1));
+  pNew->numOfColumns--;
 
   pNew->version++;
   mDebug("stb:%s, start to drop col %s", pNew->name, colName);
@@ -914,12 +915,13 @@ static int32_t mndAlterStb(SMnode *pMnode, SMnodeMsg *pReq, const SMAltertbReq *
   taosRUnLockLatch(&pOld->lock);
 
   int32_t code = -1;
+  STrans *pTrans = NULL;
 
   switch (pAlter->alterType) {
-    case TSDB_ALTER_TABLE_ADD_TAG_COLUMN:
+    case TSDB_ALTER_TABLE_ADD_TAG:
       code = mndAddSuperTableTag(pOld, &stbObj, pAlter->pSchemas, 1);
       break;
-    case TSDB_ALTER_TABLE_DROP_TAG_COLUMN:
+    case TSDB_ALTER_TABLE_DROP_TAG:
       code = mndDropSuperTableTag(pOld, &stbObj, pAlter->pSchemas[0].name);
       break;
     case TSDB_ALTER_TABLE_UPDATE_TAG_NAME:
@@ -945,7 +947,7 @@ static int32_t mndAlterStb(SMnode *pMnode, SMnodeMsg *pReq, const SMAltertbReq *
   if (code != 0) goto ALTER_STB_OVER;
 
   code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pReq->rpcMsg);
+  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pReq->rpcMsg);
   if (pTrans == NULL) goto ALTER_STB_OVER;
 
   mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name);
@@ -975,17 +977,17 @@ static int32_t mndProcessMAlterStbReq(SMnodeMsg *pReq) {
     return -1;
   }
 
-  SStbObj *pStb = mndAcquireStb(pMnode, pAlter->name);
-  if (pStb == NULL) {
-    terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+  SDbObj *pDb = mndAcquireDbByStb(pMnode, pAlter->name);
+  if (pDb == NULL) {
+    terrno = TSDB_CODE_MND_INVALID_DB;
     mError("stb:%s, failed to alter since %s", pAlter->name, terrstr());
     return -1;
   }
 
-  SDbObj *pDb = mndAcquireDbByStb(pMnode, pAlter->name);
-  if (pDb == NULL) {
-    mndReleaseStb(pMnode, pStb);
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+  SStbObj *pStb = mndAcquireStb(pMnode, pAlter->name);
+  if (pStb == NULL) {
+    mndReleaseDb(pMnode, pDb);
+    terrno = TSDB_CODE_MND_STB_NOT_EXIST;
     mError("stb:%s, failed to alter since %s", pAlter->name, terrstr());
     return -1;
   }
@@ -994,7 +996,7 @@ static int32_t mndProcessMAlterStbReq(SMnodeMsg *pReq) {
   mndReleaseStb(pMnode, pStb);
 
   if (code != 0) {
-    mError("stb:%s, failed to alter since %s", pAlter->name, tstrerror(code));
+    mError("stb:%s, failed to alter since %s", pAlter->name, terrstr());
     return code;
   }
 
diff --git a/source/dnode/mnode/impl/test/stb/stb.cpp b/source/dnode/mnode/impl/test/stb/stb.cpp
index ed0beb50a47a7f7a199b8b9bccbfee63e12a8446..465f826ca11b3917198573cc46c034e7b643f12d 100644
--- a/source/dnode/mnode/impl/test/stb/stb.cpp
+++ b/source/dnode/mnode/impl/test/stb/stb.cpp
@@ -24,7 +24,12 @@ class MndTestStb : public ::testing::Test {
 
   SCreateDbReq*   BuildCreateDbReq(const char* dbname, int32_t* pContLen);
   SMCreateStbReq* BuildCreateStbReq(const char* stbname, int32_t* pContLen);
-  SMAltertbReq*   BuildAlterStbAddTagReq(const char* stbname, int32_t* pContLen);
+  SMAltertbReq*   BuildAlterStbAddTagReq(const char* stbname, const char* tagname, int32_t* pContLen);
+  SMAltertbReq*   BuildAlterStbDropTagReq(const char* stbname, const char* tagname, int32_t* pContLen);
+  SMAltertbReq*   BuildAlterStbUpdateTagNameReq(const char* stbname, const char* tagname, const char* newtagname,
+                                                int32_t* pContLen);
+  SMAltertbReq*   BuildAlterStbDUpdateTagBytesReq(const char* stbname, const char* tagname, int32_t bytes,
+                                                  int32_t* pContLen);
 };
 
 Testbase MndTestStb::test;
@@ -58,7 +63,7 @@ SCreateDbReq* MndTestStb::BuildCreateDbReq(const char* dbname, int32_t* pContLen
   return pReq;
 }
 
-SMCreateStbReq* MndTestStb::BuildCreateStbReq(const char *stbname, int32_t* pContLen) {
+SMCreateStbReq* MndTestStb::BuildCreateStbReq(const char* stbname, int32_t* pContLen) {
   int32_t cols = 2;
   int32_t tags = 3;
   int32_t contLen = (tags + cols) * sizeof(SSchema) + sizeof(SMCreateStbReq);
@@ -107,173 +112,228 @@ SMCreateStbReq* MndTestStb::BuildCreateStbReq(const char *stbname, int32_t* pCon
   return pReq;
 }
 
-// TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
-//   const char *dbname = "1.d1";
-//   const char *stbname = "1.d1.stb";
-
-//   {
-//     int32_t       contLen = 0;
-//     SCreateDbReq* pReq = BuildCreateDbReq(dbname, &contLen);
-//     SRpcMsg*      pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
-//     ASSERT_NE(pRsp, nullptr);
-//     ASSERT_EQ(pRsp->code, 0);
-//   }
-
-//   {
-//     int32_t         contLen = 0;
-//     SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen);
-//     SRpcMsg*        pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
-//     ASSERT_NE(pRsp, nullptr);
-//     ASSERT_EQ(pRsp->code, 0);
-//   }
-
-//   {
-//     test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
-//     CHECK_META("show stables", 4);
-//     CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
-//     CHECK_SCHEMA(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
-//     CHECK_SCHEMA(2, TSDB_DATA_TYPE_INT, 4, "columns");
-//     CHECK_SCHEMA(3, TSDB_DATA_TYPE_INT, 4, "tags");
-
-//     test.SendShowRetrieveReq();
-//     EXPECT_EQ(test.GetShowRows(), 1);
-//     CheckBinary("stb", TSDB_TABLE_NAME_LEN);
-//     CheckTimestamp();
-//     CheckInt32(2);
-//     CheckInt32(3);
-//   }
-
-//   // ----- meta ------
-//   {
-//     int32_t contLen = sizeof(STableInfoReq);
-//     STableInfoReq* pReq = (STableInfoReq*)rpcMallocCont(contLen);
-//     strcpy(pReq->dbFName, dbname);
-//     strcpy(pReq->tbName, "stb");
-
-//     SRpcMsg* pMsg = test.SendReq(TDMT_MND_STB_META, pReq, contLen);
-//     ASSERT_NE(pMsg, nullptr);
-//     ASSERT_EQ(pMsg->code, 0);
-
-//     STableMetaRsp* pRsp = (STableMetaRsp*)pMsg->pCont;
-//     pRsp->numOfTags = htonl(pRsp->numOfTags);
-//     pRsp->numOfColumns = htonl(pRsp->numOfColumns);
-//     pRsp->sversion = htonl(pRsp->sversion);
-//     pRsp->tversion = htonl(pRsp->tversion);
-//     pRsp->suid = be64toh(pRsp->suid);
-//     pRsp->tuid = be64toh(pRsp->tuid);
-//     pRsp->vgId = be64toh(pRsp->vgId);
-//     for (int32_t i = 0; i < pRsp->numOfTags + pRsp->numOfColumns; ++i) {
-//       SSchema* pSchema = &pRsp->pSchema[i];
-//       pSchema->colId = htonl(pSchema->colId);
-//       pSchema->bytes = htonl(pSchema->bytes);
-//     }
-
-//     EXPECT_STREQ(pRsp->dbFName, dbname);
-//     EXPECT_STREQ(pRsp->tbName, "stb");
-//     EXPECT_STREQ(pRsp->stbName, "stb");
-//     EXPECT_EQ(pRsp->numOfColumns, 2);
-//     EXPECT_EQ(pRsp->numOfTags, 3);
-//     EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-//     EXPECT_EQ(pRsp->tableType, TSDB_SUPER_TABLE);
-//     EXPECT_EQ(pRsp->update, 0);
-//     EXPECT_EQ(pRsp->sversion, 1);
-//     EXPECT_EQ(pRsp->tversion, 0);
-//     EXPECT_GT(pRsp->suid, 0);
-//     EXPECT_GT(pRsp->tuid, 0);
-//     EXPECT_EQ(pRsp->vgId, 0);
-
-//     {
-//       SSchema* pSchema = &pRsp->pSchema[0];
-//       EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-//       EXPECT_EQ(pSchema->colId, 1);
-//       EXPECT_EQ(pSchema->bytes, 8);
-//       EXPECT_STREQ(pSchema->name, "ts");
-//     }
-
-//     {
-//       SSchema* pSchema = &pRsp->pSchema[1];
-//       EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-//       EXPECT_EQ(pSchema->colId, 2);
-//       EXPECT_EQ(pSchema->bytes, 4);
-//       EXPECT_STREQ(pSchema->name, "col1");
-//     }
-
-//     {
-//       SSchema* pSchema = &pRsp->pSchema[2];
-//       EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TINYINT);
-//       EXPECT_EQ(pSchema->colId, 3);
-//       EXPECT_EQ(pSchema->bytes, 2);
-//       EXPECT_STREQ(pSchema->name, "tag1");
-//     }
-
-//     {
-//       SSchema* pSchema = &pRsp->pSchema[3];
-//       EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BIGINT);
-//       EXPECT_EQ(pSchema->colId, 4);
-//       EXPECT_EQ(pSchema->bytes, 8);
-//       EXPECT_STREQ(pSchema->name, "tag2");
-//     }
-
-//     {
-//       SSchema* pSchema = &pRsp->pSchema[4];
-//       EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-//       EXPECT_EQ(pSchema->colId, 5);
-//       EXPECT_EQ(pSchema->bytes, 16);
-//       EXPECT_STREQ(pSchema->name, "tag3");
-//     }
-//   }
-
-//   // restart
-//   test.Restart();
-
-//   {
-//     test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
-//     CHECK_META("show stables", 4);
-//     test.SendShowRetrieveReq();
-//     EXPECT_EQ(test.GetShowRows(), 1);
-
-//     CheckBinary("stb", TSDB_TABLE_NAME_LEN);
-//     CheckTimestamp();
-//     CheckInt32(2);
-//     CheckInt32(3);
-//   }
-
-//   {
-//     int32_t contLen = sizeof(SMDropStbReq);
-
-//     SMDropStbReq* pReq = (SMDropStbReq*)rpcMallocCont(contLen);
-//     strcpy(pReq->name, stbname);
-
-//     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);
-//     ASSERT_NE(pRsp, nullptr);
-//     ASSERT_EQ(pRsp->code, 0);
-//   }
-
-//   test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
-//   CHECK_META("show stables", 4);
-//   test.SendShowRetrieveReq();
-//   EXPECT_EQ(test.GetShowRows(), 0);
-// }
-
-SMAltertbReq* MndTestStb::BuildAlterStbAddTagReq(const char* stbname, int32_t* pContLen) {
+TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
+  const char* dbname = "1.d1";
+  const char* stbname = "1.d1.stb";
+
+  {
+    int32_t       contLen = 0;
+    SCreateDbReq* pReq = BuildCreateDbReq(dbname, &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    int32_t         contLen = 0;
+    SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen);
+    SRpcMsg*        pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
+    CHECK_META("show stables", 4);
+    CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+    CHECK_SCHEMA(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+    CHECK_SCHEMA(2, TSDB_DATA_TYPE_INT, 4, "columns");
+    CHECK_SCHEMA(3, TSDB_DATA_TYPE_INT, 4, "tags");
+
+    test.SendShowRetrieveReq();
+    EXPECT_EQ(test.GetShowRows(), 1);
+    CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+    CheckTimestamp();
+    CheckInt32(2);
+    CheckInt32(3);
+  }
+
+  // ----- meta ------
+  {
+    int32_t        contLen = sizeof(STableInfoReq);
+    STableInfoReq* pReq = (STableInfoReq*)rpcMallocCont(contLen);
+    strcpy(pReq->dbFName, dbname);
+    strcpy(pReq->tbName, "stb");
+
+    SRpcMsg* pMsg = test.SendReq(TDMT_MND_STB_META, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    STableMetaRsp* pRsp = (STableMetaRsp*)pMsg->pCont;
+    pRsp->numOfTags = htonl(pRsp->numOfTags);
+    pRsp->numOfColumns = htonl(pRsp->numOfColumns);
+    pRsp->sversion = htonl(pRsp->sversion);
+    pRsp->tversion = htonl(pRsp->tversion);
+    pRsp->suid = be64toh(pRsp->suid);
+    pRsp->tuid = be64toh(pRsp->tuid);
+    pRsp->vgId = be64toh(pRsp->vgId);
+    for (int32_t i = 0; i < pRsp->numOfTags + pRsp->numOfColumns; ++i) {
+      SSchema* pSchema = &pRsp->pSchema[i];
+      pSchema->colId = htonl(pSchema->colId);
+      pSchema->bytes = htonl(pSchema->bytes);
+    }
+
+    EXPECT_STREQ(pRsp->dbFName, dbname);
+    EXPECT_STREQ(pRsp->tbName, "stb");
+    EXPECT_STREQ(pRsp->stbName, "stb");
+    EXPECT_EQ(pRsp->numOfColumns, 2);
+    EXPECT_EQ(pRsp->numOfTags, 3);
+    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRsp->tableType, TSDB_SUPER_TABLE);
+    EXPECT_EQ(pRsp->update, 0);
+    EXPECT_EQ(pRsp->sversion, 1);
+    EXPECT_EQ(pRsp->tversion, 0);
+    EXPECT_GT(pRsp->suid, 0);
+    EXPECT_GT(pRsp->tuid, 0);
+    EXPECT_EQ(pRsp->vgId, 0);
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[0];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
+      EXPECT_EQ(pSchema->colId, 1);
+      EXPECT_EQ(pSchema->bytes, 8);
+      EXPECT_STREQ(pSchema->name, "ts");
+    }
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[1];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
+      EXPECT_EQ(pSchema->colId, 2);
+      EXPECT_EQ(pSchema->bytes, 4);
+      EXPECT_STREQ(pSchema->name, "col1");
+    }
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[2];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TINYINT);
+      EXPECT_EQ(pSchema->colId, 3);
+      EXPECT_EQ(pSchema->bytes, 2);
+      EXPECT_STREQ(pSchema->name, "tag1");
+    }
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[3];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BIGINT);
+      EXPECT_EQ(pSchema->colId, 4);
+      EXPECT_EQ(pSchema->bytes, 8);
+      EXPECT_STREQ(pSchema->name, "tag2");
+    }
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[4];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
+      EXPECT_EQ(pSchema->colId, 5);
+      EXPECT_EQ(pSchema->bytes, 16);
+      EXPECT_STREQ(pSchema->name, "tag3");
+    }
+  }
+
+  // restart
+  test.Restart();
+
+  {
+    test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
+    CHECK_META("show stables", 4);
+    test.SendShowRetrieveReq();
+    EXPECT_EQ(test.GetShowRows(), 1);
+
+    CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+    CheckTimestamp();
+    CheckInt32(2);
+    CheckInt32(3);
+  }
+
+  {
+    int32_t contLen = sizeof(SMDropStbReq);
+
+    SMDropStbReq* pReq = (SMDropStbReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, stbname);
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
+  CHECK_META("show stables", 4);
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 0);
+}
+
+SMAltertbReq* MndTestStb::BuildAlterStbAddTagReq(const char* stbname, const char* tagname, int32_t* pContLen) {
+  int32_t       contLen = sizeof(SMAltertbReq) + sizeof(SSchema);
+  SMAltertbReq* pReq = (SMAltertbReq*)rpcMallocCont(contLen);
+  strcpy(pReq->name, stbname);
+  pReq->numOfSchemas = htonl(1);
+  pReq->alterType = TSDB_ALTER_TABLE_ADD_TAG;
+
+  SSchema* pSchema = &pReq->pSchemas[0];
+  pSchema->bytes = htonl(12);
+  pSchema->type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema->name, tagname);
+
+  *pContLen = contLen;
+  return pReq;
+}
+
+SMAltertbReq* MndTestStb::BuildAlterStbDropTagReq(const char* stbname, const char* tagname, int32_t* pContLen) {
+  int32_t       contLen = sizeof(SMAltertbReq) + sizeof(SSchema);
+  SMAltertbReq* pReq = (SMAltertbReq*)rpcMallocCont(contLen);
+  strcpy(pReq->name, stbname);
+  pReq->numOfSchemas = htonl(1);
+  pReq->alterType = TSDB_ALTER_TABLE_DROP_TAG;
+
+  SSchema* pSchema = &pReq->pSchemas[0];
+  pSchema->bytes = htonl(12);
+  pSchema->type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema->name, tagname);
+
+  *pContLen = contLen;
+  return pReq;
+}
+
+SMAltertbReq* MndTestStb::BuildAlterStbUpdateTagNameReq(const char* stbname, const char* tagname,
+                                                        const char* newtagname, int32_t* pContLen) {
+  int32_t       contLen = sizeof(SMAltertbReq) + 2 * sizeof(SSchema);
+  SMAltertbReq* pReq = (SMAltertbReq*)rpcMallocCont(contLen);
+  strcpy(pReq->name, stbname);
+  pReq->numOfSchemas = htonl(1);
+  pReq->alterType = TSDB_ALTER_TABLE_UPDATE_TAG_NAME;
+
+  SSchema* pSchema = &pReq->pSchemas[0];
+  pSchema->bytes = htonl(12);
+  pSchema->type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema->name, tagname);
+
+  pSchema = &pReq->pSchemas[1];
+  pSchema->bytes = htonl(12);
+  pSchema->type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema->name, newtagname);
+
+  *pContLen = contLen;
+  return pReq;
+}
+
+SMAltertbReq* MndTestStb::BuildAlterStbDUpdateTagBytesReq(const char* stbname, const char* tagname, int32_t bytes,
+                                                          int32_t* pContLen) {
   int32_t       contLen = sizeof(SMAltertbReq) + sizeof(SSchema);
   SMAltertbReq* pReq = (SMAltertbReq*)rpcMallocCont(contLen);
   strcpy(pReq->name, stbname);
   pReq->numOfSchemas = htonl(1);
-  pReq->alterType = TSDB_ALTER_TABLE_ADD_TAG_COLUMN;
+  pReq->alterType = TSDB_ALTER_TABLE_DROP_TAG;
 
   SSchema* pSchema = &pReq->pSchemas[0];
-  pSchema->bytes = htonl(4);
-  pSchema->type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema->name, "tag4");
+  pSchema->bytes = htonl(bytes);
+  pSchema->type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema->name, tagname);
 
   *pContLen = contLen;
   return pReq;
 }
 
-TEST_F(MndTestStb, 01_Alter_Stb) {
-  const char *dbname = "1.d2";
-  const char *stbname = "1.d2.stb";
+TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
+  const char* dbname = "1.d2";
+  const char* stbname = "1.d2.stb";
 
   {
     int32_t       contLen = 0;
@@ -291,9 +351,34 @@ TEST_F(MndTestStb, 01_Alter_Stb) {
     ASSERT_EQ(pRsp->code, 0);
   }
 
+  int32_t contLen = 0;
+
   {
-    int32_t       contLen = 0;
-    SMAltertbReq* pReq = BuildAlterStbAddTagReq(stbname, &contLen);
+    SMAltertbReq* pReq = BuildAlterStbAddTagReq("1.d3.stb", "tag4", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_DB);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbAddTagReq("1.d2.stb3", "tag4", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_STB_NOT_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbAddTagReq(stbname, "tag3", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbAddTagReq(stbname, "col1", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_ALREADY_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbAddTagReq(stbname, "tag4", &contLen);
     SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
@@ -307,3 +392,104 @@ TEST_F(MndTestStb, 01_Alter_Stb) {
     CheckInt32(4);
   }
 }
+
+TEST_F(MndTestStb, 03_Alter_Stb_DropTag) {
+  const char* dbname = "1.d3";
+  const char* stbname = "1.d3.stb";
+  int32_t     contLen = 0;
+
+  {
+    SCreateDbReq* pReq = BuildCreateDbReq(dbname, &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen);
+    SRpcMsg*        pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbDropTagReq(stbname, "tag5", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbDropTagReq(stbname, "tag3", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
+    test.SendShowRetrieveReq();
+    EXPECT_EQ(test.GetShowRows(), 1);
+    CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+    CheckTimestamp();
+    CheckInt32(2);
+    CheckInt32(2);
+  }
+}
+
+TEST_F(MndTestStb, 04_Alter_Stb_AddTagName) {
+  const char* dbname = "1.d4";
+  const char* stbname = "1.d4.stb";
+  int32_t     contLen = 0;
+
+  {
+    SCreateDbReq* pReq = BuildCreateDbReq(dbname, &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen);
+    SRpcMsg*        pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag5", "tag6", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "col1", "tag6", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "col1", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_ALREADY_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "tag2", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+  }
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "tag2", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+  }
+
+  {
+    SMAltertbReq* pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "tag4", &contLen);
+    SRpcMsg*      pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    test.SendShowMetaReq(TSDB_MGMT_TABLE_STB, dbname);
+    test.SendShowRetrieveReq();
+    EXPECT_EQ(test.GetShowRows(), 1);
+    CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+    CheckTimestamp();
+    CheckInt32(2);
+    CheckInt32(3);
+  }
+}
\ No newline at end of file
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 6d3e9e729f2754fa159e885eec80ea1b2a12b948..1222138b5e4c7f09b9ed4c9d21ed4bdf70122f0a 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -820,7 +820,7 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) MODIFY COLUMN columnlist(A).     {
 //////////////////////////////////ALTER TAGS statement/////////////////////////////////////
 cmd ::= ALTER TABLE ids(X) cpxName(Y) ADD TAG columnlist(A).        {
     X.n += Y.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
@@ -829,7 +829,7 @@ cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
     toTSDBType(Y.type);
     SArray* A = tListItemAppendToken(NULL, &Y, -1);
 
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
@@ -889,7 +889,7 @@ cmd ::= ALTER STABLE ids(X) cpxName(F) MODIFY COLUMN columnlist(A).     {
 //////////////////////////////////ALTER TAGS statement/////////////////////////////////////
 cmd ::= ALTER STABLE ids(X) cpxName(Y) ADD TAG columnlist(A).        {
     X.n += Y.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 cmd ::= ALTER STABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
@@ -898,7 +898,7 @@ cmd ::= ALTER STABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
     toTSDBType(Y.type);
     SArray* A = tListItemAppendToken(NULL, &Y, -1);
 
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
diff --git a/source/libs/parser/src/astGenerator.c b/source/libs/parser/src/astGenerator.c
index 9f0efbcf0e2f7d186ad15627d0b818d311378d63..5dce5120f98131eda4257fc459a34b1f209b7b1f 100644
--- a/source/libs/parser/src/astGenerator.c
+++ b/source/libs/parser/src/astGenerator.c
@@ -610,7 +610,7 @@ SAlterTableInfo *tSetAlterTableInfo(SToken *pTableName, SArray *pCols, SArray *p
   pAlterTable->type = type;
   pAlterTable->tableType = tableType;
 
-  if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || type == TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES || type == TSDB_ALTER_TABLE_UPDATE_TAG_BYTES) {
+  if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG || type == TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES || type == TSDB_ALTER_TABLE_UPDATE_TAG_BYTES) {
     pAlterTable->pAddColumns = pCols;
     assert(pVals == NULL);
   } else {
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index 2fae10d17ee62310caa32d424bae46a248169dc3..664f2a3ff2c124afea9ecec79ecdae9d6339e415 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -3206,7 +3206,7 @@ static void yy_reduce(
       case 286: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3217,7 +3217,7 @@ static void yy_reduce(
     toTSDBType(yymsp[0].minor.yy0.type);
     SArray* A = tListItemAppendToken(NULL, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3282,7 +3282,7 @@ static void yy_reduce(
       case 294: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
@@ -3293,7 +3293,7 @@ static void yy_reduce(
     toTSDBType(yymsp[0].minor.yy0.type);
     SArray* A = tListItemAppendToken(NULL, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index ca0401113c2f8c84bd4dce3ac93e3fa53e171c89..fd67067b7cd8657c1152c162279efb092a77af34 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -233,10 +233,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB,              "Invalid stable name")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB_OPTION,       "Invalid stable options")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_STB_OPTION_UNCHNAGED,     "Stable options not changed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TAGS,            "Too many tags")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_ALREAY_EXIST,         "Tag already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_ALREADY_EXIST,        "Tag already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_NOT_EXIST,            "Tag does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_COLUMNS,         "Too many columns")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_ALREAY_EXIST,      "Column already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_ALREADY_EXIST,     "Column already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_NOT_EXIST,         "Column does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ROW_BYTES,        "Invalid row bytes")