drop stb

include/common/tmsg.h

@@ -272,6 +272,9 @@ typedef struct {
   int8_t igNotExists;
 } SMDropStbReq;
 
+int32_t tSerializeSMDropStbReq(void** buf, SMDropStbReq* pReq);
+void*   tDeserializeSMDropStbReq(void* buf, SMDropStbReq* pReq);
+
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  alterType;

source/common/src/tmsg.c

@@ -399,3 +399,19 @@ void *tDeserializeSMCreateStbReq(void *buf, SMCreateStbReq *pReq) {
 
   return buf;
 }
+
+int32_t tSerializeSMDropStbReq(void **buf, SMDropStbReq *pReq) {
+  int32_t tlen = 0;
+
+  tlen += taosEncodeString(buf, pReq->name);
+  tlen += taosEncodeFixedI8(buf, pReq->igNotExists);
+
+  return tlen;
+}
+
+void *tDeserializeSMDropStbReq(void *buf, SMDropStbReq *pReq) {
+  buf = taosDecodeStringTo(buf, pReq->name);
+  buf = taosDecodeFixedI8(buf, &pReq->igNotExists);
+
+  return buf;
+}

source/dnode/mnode/impl/src/mndStb.c

@@ -1118,28 +1118,30 @@ DROP_STB_OVER:
 }
 
 static int32_t mndProcessMDropStbReq(SMnodeMsg *pReq) {
-  SMnode       *pMnode = pReq->pMnode;
+  SMnode *pMnode = pReq->pMnode;
-  SMDropStbReq *pDrop = pReq->rpcMsg.pCont;
 
-  mDebug("stb:%s, start to drop", pDrop->name);
+  SMDropStbReq dropReq = {0};
+  tDeserializeSMDropStbReq(pReq->rpcMsg.pCont, &dropReq);
 
-  SStbObj *pStb = mndAcquireStb(pMnode, pDrop->name);
+  mDebug("stb:%s, start to drop", dropReq.name);
+
+  SStbObj *pStb = mndAcquireStb(pMnode, dropReq.name);
   if (pStb == NULL) {
-    if (pDrop->igNotExists) {
+    if (dropReq.igNotExists) {
-      mDebug("stb:%s, not exist, ignore not exist is set", pDrop->name);
+      mDebug("stb:%s, not exist, ignore not exist is set", dropReq.name);
       return 0;
     } else {
       terrno = TSDB_CODE_MND_STB_NOT_EXIST;
-      mError("stb:%s, failed to drop since %s", pDrop->name, terrstr());
+      mError("stb:%s, failed to drop since %s", dropReq.name, terrstr());
       return -1;
     }
   }
 
-  SDbObj *pDb = mndAcquireDbByStb(pMnode, pDrop->name);
+  SDbObj *pDb = mndAcquireDbByStb(pMnode, dropReq.name);
   if (pDb == NULL) {
     mndReleaseStb(pMnode, pStb);
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    mError("stb:%s, failed to drop since %s", pDrop->name, terrstr());
+    mError("stb:%s, failed to drop since %s", dropReq.name, terrstr());
     return -1;
   }
 
@@ -1148,7 +1150,7 @@ static int32_t mndProcessMDropStbReq(SMnodeMsg *pReq) {
   mndReleaseStb(pMnode, pStb);
 
   if (code != 0) {
-    mError("stb:%s, failed to drop since %s", pDrop->name, terrstr());
+    mError("stb:%s, failed to drop since %s", dropReq.name, terrstr());
     return -1;
   }
 

source/dnode/mnode/impl/test/stb/stb.cpp

@@ -388,12 +388,15 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropStbReq);
+    SMDropStbReq dropReq = {0};
+    strcpy(dropReq.name, stbname);
 
-    SMDropStbReq* pReq = (SMDropStbReq*)rpcMallocCont(contLen);
+    int32_t contLen = tSerializeSMDropStbReq(NULL, &dropReq);
-    strcpy(pReq->name, stbname);
+    void*   pHead = rpcMallocCont(contLen);
+    void*   pBuf = pHead;
+    tSerializeSMDropStbReq(&pBuf, &dropReq);
 
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pHead, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
   }

source/libs/parser/inc/astToMsg.h

@@ -10,8 +10,8 @@ SCreateAcctReq* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, in
 SDropUserReq* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
 SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf);
-SMCreateStbReq*   buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
+char* buildCreateStbReq(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
-SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
+char* buildDropStableReq(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
 SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf);
 SDropDnodeReq *buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf);
 

source/libs/parser/src/astToMsg.c

@@ -249,8 +249,7 @@ SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx
   return pCreateMsg;
 }
 
-SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx,
+char* buildCreateStbReq(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
-                                  SMsgBuf* pMsgBuf) {
   SMCreateStbReq createReq = {0};
   createReq.igExists = pCreateTableSql->existCheck ? 1 : 0;
   createReq.pColumns = pCreateTableSql->colInfo.pColumns;
@@ -275,30 +274,39 @@ SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len
     return NULL;
   }
 
-  void *buf = req;
+  void* buf = req;
   tSerializeSMCreateStbReq(&buf, &createReq);
   *len = tlen;
   return req;
 }
 
-SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
+char* buildDropStableReq(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
   SToken* tableName = taosArrayGet(pInfo->pMiscInfo->a, 0);
 
-  SName name = {0};
+  SName   name = {0};
   int32_t code = createSName(&name, tableName, pParseCtx, pMsgBuf);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = buildInvalidOperationMsg(pMsgBuf, "invalid table name");
     return NULL;
   }
 
-  SMDropStbReq *pDropTableMsg = (SMDropStbReq*) calloc(1, sizeof(SMDropStbReq));
+  SMDropStbReq dropReq = {0};
+  code = tNameExtractFullName(&name, dropReq.name);
 
-  code = tNameExtractFullName(&name, pDropTableMsg->name);
   assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_TABLE_NAME_T);
+  dropReq.igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
 
-  pDropTableMsg->igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
+  int32_t tlen = tSerializeSMDropStbReq(NULL, &dropReq);
-  *len = sizeof(SMDropStbReq);
+  void*   req = malloc(tlen);
-  return pDropTableMsg;
+  if (req == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  void* buf = req;
+  tSerializeSMDropStbReq(&buf, &dropReq);
+  *len = tlen;
+  return req;
 }
 
 SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf) {

source/libs/parser/src/dCDAstProcess.c

@@ -924,13 +924,13 @@ SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, ch
         goto _error;
       }
 
-      pDcl->pMsg = (char*)buildCreateStbMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
+      pDcl->pMsg = buildCreateStbReq(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
       pDcl->msgType = TDMT_MND_CREATE_STB;
       break;
     }
 
     case TSDB_SQL_DROP_TABLE: {
-      pDcl->pMsg = (char*)buildDropStableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
+      pDcl->pMsg = buildDropStableReq(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
       if (pDcl->pMsg == NULL) {
         goto _error;
       }