taosdata / TDengine / #4875

coverage: 64.472% (-0.2%) from 64.623%
#4875

push

travis-ci

guanshengliang 
fix: temporarily disable memory leak detection for UDF tests (#33856)

162014 of 251293 relevant lines covered (64.47%)

104318075.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.64
/source/dnode/mnode/impl/src/mndTopic.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *f
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#include "mndTopic.h"










17



#include "mndConsumer.h"










18



#include "mndDb.h"










19



#include "mndDnode.h"










20



#include "mndMnode.h"










21



#include "mndPrivilege.h"










22



#include "mndShow.h"










23



#include "mndStb.h"










24



#include "mndSubscribe.h"










25



#include "mndTrans.h"










26



#include "mndUser.h"










27



#include "mndVgroup.h"










28



#include "parser.h"










29



#include "tname.h"










30



#include "audit.h"










31












32



#define MND_TOPIC_VER_NUMBER   3










33



#define MND_TOPIC_RESERVE_SIZE 64










34












35



SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic);










36



SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw);










37












38



static int32_t mndTopicActionInsert(SSdb *pSdb, SMqTopicObj *pTopic);










39



static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic);










40



static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic);










41



static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq);










42



static int32_t mndProcessDropTopicReq(SRpcMsg *pReq);










43












44



static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);










45



static void    mndCancelGetNextTopic(SMnode *pMnode, void *pIter);










46












47



int32_t mndInitTopic(SMnode *pMnode) {




503,969✔





48



  SSdbTable table = {




503,969✔





49



      .sdbType = SDB_TOPIC,










50



      .keyType = SDB_KEY_BINARY,










51



      .encodeFp = (SdbEncodeFp)mndTopicActionEncode,










52



      .decodeFp = (SdbDecodeFp)mndTopicActionDecode,










53



      .insertFp = (SdbInsertFp)mndTopicActionInsert,










54



      .updateFp = (SdbUpdateFp)mndTopicActionUpdate,










55



      .deleteFp = (SdbDeleteFp)mndTopicActionDelete,










56



  };










57












58



  if (pMnode == NULL) {




503,969✔





59



    return TSDB_CODE_INVALID_PARA;




×







60



  }










61



  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CREATE_TOPIC, mndProcessCreateTopicReq);




503,969✔





62



  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_DROP_TOPIC, mndProcessDropTopicReq);




503,969✔





63



  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_ADD_CHECKINFO_RSP, mndTransProcessRsp);




503,969✔





64



  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_DEL_CHECKINFO_RSP, mndTransProcessRsp);




503,969✔





65












66



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndRetrieveTopic);




503,969✔





67



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndCancelGetNextTopic);




503,969✔





68












69



  return sdbSetTable(pMnode->pSdb, table);




503,969✔





70



}










71












72



void mndCleanupTopic(SMnode *pMnode) {}




503,156✔





73












74



void mndTopicGetShowName(const char* fullTopic, char* topic) {




15,059✔





75



  if (fullTopic == NULL) {




15,059✔





76



    return;




×







77



  }










78



  char* tmp = strchr(fullTopic, '.');




15,059✔





79



  if (tmp == NULL) {




15,059✔





80



    tstrncpy(topic, fullTopic, TSDB_TOPIC_FNAME_LEN);




×







81



  }else {










82



    tstrncpy(topic, tmp+1, TSDB_TOPIC_FNAME_LEN);




15,059✔





83



  }










84



}










85












86



SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {




109,879✔





87



  if (pTopic == NULL) {




109,879✔





88



    return NULL;




×







89



  }










90



  int32_t code = 0;




109,879✔





91



  int32_t lino = 0;




109,879✔





92



  terrno = TSDB_CODE_OUT_OF_MEMORY;




109,879✔





93












94



  void   *swBuf = NULL;




109,879✔





95



  int32_t physicalPlanLen = 0;




109,879✔





96



  if (pTopic->physicalPlan) {




109,879✔





97



    physicalPlanLen = strlen(pTopic->physicalPlan) + 1;




89,255✔





98



  }










99












100



  int32_t schemaLen = 0;




109,879✔





101



  if (pTopic->schema.nCols) {




109,879✔





102



    schemaLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema);




178,510✔





103



  }










104



  int32_t ntbColLen = taosArrayGetSize(pTopic->ntbColIds) * sizeof(int16_t);




109,879✔





105












106



  int32_t size = sizeof(SMqTopicObj) + physicalPlanLen + pTopic->sqlLen + pTopic->astLen + schemaLen + ntbColLen +




109,879✔





107



                 MND_TOPIC_RESERVE_SIZE;










108



  SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size);




109,879✔





109



  if (pRaw == NULL) {




109,879✔





110



    goto TOPIC_ENCODE_OVER;




×







111



  }










112












113



  int32_t dataPos = 0;




109,879✔





114



  SDB_SET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TOPIC_FNAME_LEN, TOPIC_ENCODE_OVER);




109,879✔





115



  SDB_SET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN, TOPIC_ENCODE_OVER);




109,879✔





116



  SDB_SET_BINARY(pRaw, dataPos, pTopic->createUser, TSDB_USER_LEN, TOPIC_ENCODE_OVER);




109,879✔





117



  SDB_SET_INT64(pRaw, dataPos, pTopic->createTime, TOPIC_ENCODE_OVER);




109,879✔





118



  SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime, TOPIC_ENCODE_OVER);




109,879✔





119



  SDB_SET_INT64(pRaw, dataPos, pTopic->uid, TOPIC_ENCODE_OVER);




109,879✔





120



  SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid, TOPIC_ENCODE_OVER);




109,879✔





121



  SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER);




109,879✔





122



  SDB_SET_INT8(pRaw, dataPos, pTopic->subType, TOPIC_ENCODE_OVER);




109,879✔





123



  SDB_SET_INT8(pRaw, dataPos, pTopic->withMeta, TOPIC_ENCODE_OVER);




109,879✔





124












125



  SDB_SET_INT64(pRaw, dataPos, pTopic->stbUid, TOPIC_ENCODE_OVER);




109,879✔





126



  SDB_SET_BINARY(pRaw, dataPos, pTopic->stbName, TSDB_TABLE_FNAME_LEN, TOPIC_ENCODE_OVER);




109,879✔





127



  SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen, TOPIC_ENCODE_OVER);




109,879✔





128



  SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_ENCODE_OVER);




109,879✔





129



  SDB_SET_INT32(pRaw, dataPos, pTopic->astLen, TOPIC_ENCODE_OVER);




109,879✔





130












131



  if (pTopic->astLen) {




109,879✔





132



    SDB_SET_BINARY(pRaw, dataPos, pTopic->ast, pTopic->astLen, TOPIC_ENCODE_OVER);




96,241✔





133



  }










134



  SDB_SET_INT32(pRaw, dataPos, physicalPlanLen, TOPIC_ENCODE_OVER);




109,879✔





135



  if (physicalPlanLen) {




109,879✔





136



    SDB_SET_BINARY(pRaw, dataPos, pTopic->physicalPlan, physicalPlanLen, TOPIC_ENCODE_OVER);




89,255✔





137



  }










138



  SDB_SET_INT32(pRaw, dataPos, schemaLen, TOPIC_ENCODE_OVER);




109,879✔





139



  if (schemaLen) {




109,879✔





140



    swBuf = taosMemoryMalloc(schemaLen);




89,255✔





141



    if (swBuf == NULL) {




89,255✔





142



      goto TOPIC_ENCODE_OVER;




×







143



    }










144



    void *aswBuf = swBuf;




89,255✔





145



    if(taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema) < 0){




178,510✔





146



      goto TOPIC_ENCODE_OVER;




×







147



    }










148



    SDB_SET_BINARY(pRaw, dataPos, swBuf, schemaLen, TOPIC_ENCODE_OVER);




89,255✔





149



  }










150












151



  SDB_SET_INT64(pRaw, dataPos, pTopic->ntbUid, TOPIC_ENCODE_OVER);




109,879✔





152



  if (pTopic->ntbUid != 0) {




109,879✔





153



    int32_t sz = taosArrayGetSize(pTopic->ntbColIds);




10,297✔





154



    SDB_SET_INT32(pRaw, dataPos, sz, TOPIC_ENCODE_OVER);




10,297✔





155



    for (int32_t i = 0; i < sz; i++) {




27,063✔





156



      int16_t colId = *(int16_t *)taosArrayGet(pTopic->ntbColIds, i);




16,766✔





157



      SDB_SET_INT16(pRaw, dataPos, colId, TOPIC_ENCODE_OVER);




16,766✔





158



    }










159



  }










160












161



  SDB_SET_INT64(pRaw, dataPos, pTopic->ctbStbUid, TOPIC_ENCODE_OVER);




109,879✔





162












163



  SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_ENCODE_OVER);




109,879✔





164



  SDB_SET_DATALEN(pRaw, dataPos, TOPIC_ENCODE_OVER);




109,879✔





165












166



  terrno = TSDB_CODE_SUCCESS;




109,879✔





167












168



TOPIC_ENCODE_OVER:




109,879✔





169



  if (swBuf) taosMemoryFree(swBuf);




109,879✔





170



  if (terrno != TSDB_CODE_SUCCESS) {




109,879✔





171



    mError("topic:%s, failed to encode to raw:%p since %s", pTopic->name, pRaw, terrstr());




×







172



    sdbFreeRaw(pRaw);




×







173



    return NULL;




×







174



  }










175












176



  mTrace("topic:%s, encode to raw:%p, row:%p", pTopic->name, pRaw, pTopic);




109,879✔





177



  return pRaw;




109,879✔





178



}










179












180



SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {




91,992✔





181



  if (pRaw == NULL) return NULL;




91,992✔





182



  int32_t code = 0;




91,992✔





183



  int32_t lino = 0;




91,992✔





184



  terrno = TSDB_CODE_OUT_OF_MEMORY;




91,992✔





185



  SSdbRow     *pRow = NULL;




91,992✔





186



  SMqTopicObj *pTopic = NULL;




91,992✔





187



  void        *buf = NULL;




91,992✔





188












189



  int8_t sver = 0;




91,992✔





190



  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto TOPIC_DECODE_OVER;




91,992✔





191












192



  if (sver < 1 || sver > MND_TOPIC_VER_NUMBER) {




91,992✔





193



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







194



    goto TOPIC_DECODE_OVER;




×







195



  }










196












197



  pRow = sdbAllocRow(sizeof(SMqTopicObj));




91,992✔





198



  if (pRow == NULL) goto TOPIC_DECODE_OVER;




91,992✔





199












200



  pTopic = sdbGetRowObj(pRow);




91,992✔





201



  if (pTopic == NULL) goto TOPIC_DECODE_OVER;




91,992✔





202












203



  int32_t len = 0;




91,992✔





204



  int32_t dataPos = 0;




91,992✔





205



  SDB_GET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TOPIC_FNAME_LEN, TOPIC_DECODE_OVER);




91,992✔





206



  SDB_GET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN, TOPIC_DECODE_OVER);




91,992✔





207



  if (sver >= 2) {




91,992✔





208



    SDB_GET_BINARY(pRaw, dataPos, pTopic->createUser, TSDB_USER_LEN, TOPIC_DECODE_OVER);




91,992✔





209



  }










210



  SDB_GET_INT64(pRaw, dataPos, &pTopic->createTime, TOPIC_DECODE_OVER);




91,992✔





211



  SDB_GET_INT64(pRaw, dataPos, &pTopic->updateTime, TOPIC_DECODE_OVER);




91,992✔





212



  SDB_GET_INT64(pRaw, dataPos, &pTopic->uid, TOPIC_DECODE_OVER);




91,992✔





213



  SDB_GET_INT64(pRaw, dataPos, &pTopic->dbUid, TOPIC_DECODE_OVER);




91,992✔





214



  SDB_GET_INT32(pRaw, dataPos, &pTopic->version, TOPIC_DECODE_OVER);




91,992✔





215



  SDB_GET_INT8(pRaw, dataPos, &pTopic->subType, TOPIC_DECODE_OVER);




91,992✔





216



  SDB_GET_INT8(pRaw, dataPos, &pTopic->withMeta, TOPIC_DECODE_OVER);




91,992✔





217












218



  SDB_GET_INT64(pRaw, dataPos, &pTopic->stbUid, TOPIC_DECODE_OVER);




91,992✔





219



  if (sver >= 3) {




91,992✔





220



    SDB_GET_BINARY(pRaw, dataPos, pTopic->stbName, TSDB_TABLE_FNAME_LEN, TOPIC_DECODE_OVER);




91,992✔





221



  }










222



  SDB_GET_INT32(pRaw, dataPos, &pTopic->sqlLen, TOPIC_DECODE_OVER);




91,992✔





223



  pTopic->sql = taosMemoryCalloc(pTopic->sqlLen, sizeof(char));




91,992✔





224



  if (pTopic->sql == NULL) {




91,992✔





225



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







226



    goto TOPIC_DECODE_OVER;




×







227



  }










228



  SDB_GET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_DECODE_OVER);




91,992✔





229












230



  SDB_GET_INT32(pRaw, dataPos, &pTopic->astLen, TOPIC_DECODE_OVER);




91,992✔





231



  if (pTopic->astLen) {




91,992✔





232



    pTopic->ast = taosMemoryCalloc(pTopic->astLen, sizeof(char));




80,422✔





233



    if (pTopic->ast == NULL) {




80,422✔





234



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







235



      goto TOPIC_DECODE_OVER;




×







236



    }










237



  } else {










238



    pTopic->ast = NULL;




11,570✔





239



  }










240



  SDB_GET_BINARY(pRaw, dataPos, pTopic->ast, pTopic->astLen, TOPIC_DECODE_OVER);




91,992✔





241



  SDB_GET_INT32(pRaw, dataPos, &len, TOPIC_DECODE_OVER);




91,992✔





242



  if (len) {




91,992✔





243



    pTopic->physicalPlan = taosMemoryCalloc(len, sizeof(char));




76,989✔





244



    if (pTopic->physicalPlan == NULL) {




76,989✔





245



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







246



      goto TOPIC_DECODE_OVER;




×







247



    }










248



    SDB_GET_BINARY(pRaw, dataPos, pTopic->physicalPlan, len, TOPIC_DECODE_OVER);




76,989✔





249



  } else {










250



    pTopic->physicalPlan = NULL;




15,003✔





251



  }










252












253



  SDB_GET_INT32(pRaw, dataPos, &len, TOPIC_DECODE_OVER);




91,992✔





254



  if (len) {




91,992✔





255



    buf = taosMemoryMalloc(len);




76,989✔





256



    if (buf == NULL) {




76,989✔





257



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







258



      goto TOPIC_DECODE_OVER;




×







259



    }










260



    SDB_GET_BINARY(pRaw, dataPos, buf, len, TOPIC_DECODE_OVER);




76,989✔





261



    if (taosDecodeSSchemaWrapper(buf, &pTopic->schema) == NULL) {




153,978✔





262



      goto TOPIC_DECODE_OVER;




×







263



    }










264



  } else {










265



    pTopic->schema.nCols = 0;




15,003✔





266



    pTopic->schema.version = 0;




15,003✔





267



    pTopic->schema.pSchema = NULL;




15,003✔





268



  }










269



  SDB_GET_INT64(pRaw, dataPos, &pTopic->ntbUid, TOPIC_DECODE_OVER);




91,992✔





270



  if (pTopic->ntbUid != 0) {




91,992✔





271



    int32_t ntbColNum;




8,461✔





272



    SDB_GET_INT32(pRaw, dataPos, &ntbColNum, TOPIC_DECODE_OVER);




8,461✔





273



    pTopic->ntbColIds = taosArrayInit(ntbColNum, sizeof(int16_t));




8,461✔





274



    if (pTopic->ntbColIds == NULL) {




8,461✔





275



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







276



      goto TOPIC_DECODE_OVER;




×







277



    }










278



    int16_t colId;




8,461✔





279



    SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER);




8,461✔





280



    if (taosArrayPush(pTopic->ntbColIds, &colId) == NULL) {




16,922✔





281



      goto TOPIC_DECODE_OVER;




×







282



    }










283



  }










284












285



  SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER);




91,992✔





286



  SDB_GET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_DECODE_OVER);




91,992✔





287



  terrno = TSDB_CODE_SUCCESS;




91,992✔





288












289



TOPIC_DECODE_OVER:




91,992✔





290



  taosMemoryFreeClear(buf);




91,992✔





291



  if (terrno != TSDB_CODE_SUCCESS) {




91,992✔





292



    mError("topic:%s, failed to decode from raw:%p since %s", pTopic == NULL ? "null" : pTopic->name, pRaw, terrstr());




×







293



    taosMemoryFreeClear(pRow);




×







294



    return NULL;




×







295



  }










296












297



  mTrace("topic:%s, decode from raw:%p, row:%p", pTopic->name, pRaw, pTopic);




91,992✔





298



  return pRow;




91,992✔





299



}










300












301



static int32_t mndTopicActionInsert(SSdb *pSdb, SMqTopicObj *pTopic) {




58,357✔





302



  mTrace("topic:%s perform insert action", pTopic != NULL ? pTopic->name : "null");




58,357✔





303



  return 0;




58,357✔





304



}










305












306



static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) {




91,992✔





307



  if (pTopic == NULL) return 0;




91,992✔





308



  mTrace("topic:%s perform delete action", pTopic->name);




91,992✔





309



  taosMemoryFreeClear(pTopic->sql);




91,992✔





310



  taosMemoryFreeClear(pTopic->ast);




91,992✔





311



  taosMemoryFreeClear(pTopic->physicalPlan);




91,992✔





312



  if (pTopic->schema.nCols) taosMemoryFreeClear(pTopic->schema.pSchema);




91,992✔





313



  taosArrayDestroy(pTopic->ntbColIds);




91,992✔





314



  return 0;




91,992✔





315



}










316












317



static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic) {




×







318



  if (pOldTopic == NULL || pNewTopic == NULL) return 0;




×







319



  mTrace("topic:%s perform update action", pOldTopic->name);




×







320



  (void)atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);




×







321



  (void)atomic_exchange_32(&pOldTopic->version, pNewTopic->version);




×







322












323



  return 0;




×







324



}










325












326



int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic) {




554,329✔





327



  if (pMnode == NULL || topicName == NULL || pTopic == NULL){




554,329✔





328



    return TSDB_CODE_INVALID_PARA;




×







329



  }










330



  SSdb        *pSdb = pMnode->pSdb;




554,329✔





331



  *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);




554,329✔





332



  if (*pTopic == NULL) {




554,329✔





333



    return TSDB_CODE_MND_TOPIC_NOT_EXIST;




56,450✔





334



  }










335



  return TSDB_CODE_SUCCESS;




497,879✔





336



}










337












338



void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {




551,920✔





339



  if (pMnode == NULL) return;




551,920✔





340



  SSdb *pSdb = pMnode->pSdb;




551,920✔





341



  sdbRelease(pSdb, pTopic);




551,920✔





342



}










343












344



static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {




53,845✔





345



  if (pCreate == NULL) return TSDB_CODE_INVALID_PARA;




53,845✔





346



  if (pCreate->sql == NULL) return TSDB_CODE_MND_INVALID_TOPIC;




53,845✔





347












348



  if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {




53,845✔





349



    if (pCreate->ast == NULL || pCreate->ast[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;




41,897✔





350



  } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {




11,948✔





351



    if (pCreate->subStbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;




5,166✔





352



  } else if (pCreate->subType == TOPIC_SUB_TYPE__DB) {




6,782✔





353



    if (pCreate->subDbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;




6,782✔





354



  }










355












356



  return 0;




53,845✔





357



}










358












359



static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {




39,521✔





360



  if (pAst == NULL || pTopic == NULL) return TSDB_CODE_INVALID_PARA;




39,521✔





361



  SNodeList *pNodeList = NULL;




39,521✔





362



  int32_t   code = 0;




39,521✔





363



  MND_TMQ_RETURN_CHECK(nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList));




39,521✔





364



  int64_t suid = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->suid;




39,521✔





365



  int8_t  tableType = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->tableType;




39,521✔





366



  if (tableType == TSDB_CHILD_TABLE) {




39,521✔





367



    pTopic->ctbStbUid = suid;




1,984✔





368



  } else if (tableType == TSDB_NORMAL_TABLE) {




37,537✔





369



    SNode *pNode = NULL;




3,576✔





370



    FOREACH(pNode, pNodeList) {




13,621✔





371



      SColumnNode *pCol = (SColumnNode *)pNode;




10,045✔





372



      if (pCol->tableType == TSDB_NORMAL_TABLE) {




10,045✔





373



        pTopic->ntbUid = pCol->tableId;




10,045✔





374



        MND_TMQ_NULL_CHECK(taosArrayPush(pTopic->ntbColIds, &pCol->colId));




20,090✔





375



      }










376



    }










377



  }










378



  nodesDestroyList(pNodeList);




39,521✔





379












380



END:




39,521✔





381



  return code;




39,521✔





382



}










383












384



static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj *topicObj){




3,576✔





385



  if (pTrans == NULL || pMnode == NULL || topicObj == NULL) return TSDB_CODE_INVALID_PARA;




3,576✔





386



  STqCheckInfo info = {0};




3,576✔





387



  (void)memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);




3,576✔





388



  info.ntbUid = topicObj->ntbUid;




3,576✔





389



  info.colIdList = topicObj->ntbColIds;




3,576✔





390



  // broadcast forbid alter info










391



  void   *pIter = NULL;




3,576✔





392



  SSdb   *pSdb = pMnode->pSdb;




3,576✔





393



  SVgObj *pVgroup = NULL;




3,576✔





394



  int32_t code = 0;




3,576✔





395



  void   *buf = NULL;




3,576✔





396












397



  while (1) {




13,059✔





398



    // iterate vg










399



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




16,635✔





400



    if (pIter == NULL) break;




16,635✔





401



    if (pVgroup->mountVgId) {




13,059✔





402



      sdbRelease(pSdb, pVgroup);




×







403



      continue;




×







404



    }










405



    if (!mndVgroupInDb(pVgroup, topicObj->dbUid)) {




13,059✔





406



      sdbRelease(pSdb, pVgroup);




6,363✔





407



      continue;




6,363✔





408



    }










409












410



    // encoder check alter info










411



    int32_t len = 0;




6,696✔





412



    tEncodeSize(tEncodeSTqCheckInfo, &info, len, code);




6,696✔





413



    if (code != 0) {




6,696✔





414



      code = TSDB_CODE_OUT_OF_MEMORY;




×







415



      goto END;




×







416



    }










417



    buf = taosMemoryCalloc(1, sizeof(SMsgHead) + len);




6,696✔





418



    MND_TMQ_NULL_CHECK(buf);




6,696✔





419



    void    *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));




6,696✔





420



    SEncoder encoder = {0};




6,696✔





421



    tEncoderInit(&encoder, abuf, len);




6,696✔





422



    code = tEncodeSTqCheckInfo(&encoder, &info);




6,696✔





423



    if (code < 0) {




6,696✔





424



      tEncoderClear(&encoder);




×







425



      goto END;




×







426



    }










427



    tEncoderClear(&encoder);




6,696✔





428



    ((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId);




6,696✔





429



    // add redo action










430



    STransAction action = {0};




6,696✔





431



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




6,696✔





432



    action.pCont = buf;




6,696✔





433



    action.contLen = sizeof(SMsgHead) + len;




6,696✔





434



    action.msgType = TDMT_VND_TMQ_ADD_CHECKINFO;




6,696✔





435



    MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));




6,696✔





436



    sdbRelease(pSdb, pVgroup);




6,696✔





437



    buf = NULL;




6,696✔





438



  }










439












440



END:




3,576✔





441



  taosMemoryFree(buf);




3,576✔





442



  sdbRelease(pSdb, pVgroup);




3,576✔





443



  sdbCancelFetch(pSdb, pIter);




3,576✔





444



  return code;




3,576✔





445



}










446












447



static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *pCreate, SDbObj *pDb,




52,205✔





448



                              const char *userName) {










449



  if (pMnode == NULL || pReq == NULL || pCreate == NULL || pDb == NULL || userName == NULL) return TSDB_CODE_INVALID_PARA;




52,205✔





450



  mInfo("start to create topic:%s", pCreate->name);




52,205✔





451



  STrans *pTrans = NULL;




52,205✔





452



  int32_t code = 0;




52,205✔





453



  SNode  *pAst = NULL;




52,205✔





454



  SQueryPlan *pPlan = NULL;




52,205✔





455



  SMqTopicObj topicObj = {0};




52,205✔





456












457



  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "create-topic");




52,205✔





458



  MND_TMQ_NULL_CHECK(pTrans);




52,205✔





459



  mndTransSetDbName(pTrans, pDb->name, NULL);




52,205✔





460



  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));




52,205✔





461



  mInfo("trans:%d to create topic:%s", pTrans->id, pCreate->name);




52,205✔





462












463



  tstrncpy(topicObj.name, pCreate->name, TSDB_TOPIC_FNAME_LEN);




52,205✔





464



  tstrncpy(topicObj.db, pDb->name, TSDB_DB_FNAME_LEN);




52,205✔





465



  tstrncpy(topicObj.createUser, userName, TSDB_USER_LEN);




52,205✔





466












467



  MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj));




52,205✔





468












469



  topicObj.createTime = taosGetTimestampMs();




50,421✔





470



  topicObj.updateTime = topicObj.createTime;




50,421✔





471



  topicObj.uid = mndGenerateUid(pCreate->name, strlen(pCreate->name));




50,421✔





472



  topicObj.dbUid = pDb->uid;




50,421✔





473



  topicObj.version = 1;




50,421✔





474



  topicObj.sql = taosStrdup(pCreate->sql);




50,421✔





475



  MND_TMQ_NULL_CHECK(topicObj.sql);




50,421✔





476



  topicObj.sqlLen = strlen(pCreate->sql) + 1;




50,421✔





477



  topicObj.subType = pCreate->subType;




50,421✔





478



  topicObj.withMeta = pCreate->withMeta;




50,421✔





479












480



  if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {




50,421✔





481



    topicObj.ast = taosStrdup(pCreate->ast);




39,521✔





482



    MND_TMQ_NULL_CHECK(topicObj.ast);




39,521✔





483



    topicObj.astLen = strlen(pCreate->ast) + 1;




39,521✔





484



    qDebugL("topic:%s ast %s", topicObj.name, topicObj.ast);




39,521✔





485



    MND_TMQ_RETURN_CHECK(nodesStringToNode(pCreate->ast, &pAst));




39,521✔





486



    SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};




39,521✔





487



    MND_TMQ_RETURN_CHECK(qCreateQueryPlan(&cxt, &pPlan, NULL));




39,521✔





488












489



    topicObj.ntbColIds = taosArrayInit(0, sizeof(int16_t));




39,521✔





490



    MND_TMQ_NULL_CHECK(topicObj.ntbColIds);




39,521✔





491



    MND_TMQ_RETURN_CHECK(extractTopicTbInfo(pAst, &topicObj));




39,521✔





492



    if (topicObj.ntbUid == 0) {




39,521✔





493



      taosArrayDestroy(topicObj.ntbColIds);




35,945✔





494



      topicObj.ntbColIds = NULL;




35,945✔





495



    }










496












497



    MND_TMQ_RETURN_CHECK(qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema));




39,521✔





498



    MND_TMQ_RETURN_CHECK(nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL));




39,521✔





499



  } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {




10,900✔





500



    SStbObj *pStb = mndAcquireStb(pMnode, pCreate->subStbName);




5,166✔





501



    MND_TMQ_NULL_CHECK(pStb);




5,166✔





502



    tstrncpy(topicObj.stbName, pCreate->subStbName, TSDB_TABLE_FNAME_LEN);




4,166✔





503



    topicObj.stbUid = pStb->uid;




4,166✔





504



    mndReleaseStb(pMnode, pStb);




4,166✔





505



    if(pCreate->ast != NULL){




4,166✔





506



      qDebugL("topic:%s ast %s", topicObj.name, pCreate->ast);




3,433✔





507



      topicObj.ast = taosStrdup(pCreate->ast);




3,433✔





508



      MND_TMQ_NULL_CHECK(topicObj.ast);




3,433✔





509



      topicObj.astLen = strlen(pCreate->ast) + 1;




3,433✔





510



    }










511



  }










512












513



  SSdbRaw *pCommitRaw = mndTopicActionEncode(&topicObj);




49,421✔





514



  MND_TMQ_NULL_CHECK(pCommitRaw);




49,421✔





515



  code = mndTransAppendCommitlog(pTrans, pCommitRaw);




49,421✔





516



  if(code != 0) {




49,421✔





517



    sdbFreeRaw(pCommitRaw);




×







518



    goto END;




×







519



  }










520












521



  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));




49,421✔





522



  if (topicObj.ntbUid != 0) {




49,421✔





523



    MND_TMQ_RETURN_CHECK(sendCheckInfoToVnode(pTrans, pMnode, &topicObj));




3,576✔





524



  }










525



  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));




49,421✔





526



  code = TSDB_CODE_ACTION_IN_PROGRESS;




49,421✔





527












528



END:




52,205✔





529



  taosMemoryFreeClear(topicObj.physicalPlan);




52,205✔





530



  taosMemoryFreeClear(topicObj.sql);




52,205✔





531



  taosMemoryFreeClear(topicObj.ast);




52,205✔





532



  taosArrayDestroy(topicObj.ntbColIds);




52,205✔





533



  if (topicObj.schema.nCols) {




52,205✔





534



    taosMemoryFreeClear(topicObj.schema.pSchema);




39,521✔





535



  }










536



  nodesDestroyNode(pAst);




52,205✔





537



  nodesDestroyNode((SNode *)pPlan);




52,205✔





538



  mndTransDrop(pTrans);




52,205✔





539



  return code;




52,205✔





540



}










541












542



static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {




53,845✔





543



  if (pReq == NULL || pReq->contLen <= 0) {




53,845✔





544



    return TSDB_CODE_INVALID_MSG;




×







545



  }










546



  SMnode           *pMnode = pReq->info.node;




53,845✔





547



  int32_t           code = TSDB_CODE_SUCCESS;




53,845✔





548



  SMqTopicObj      *pTopic = NULL;




53,845✔





549



  SDbObj           *pDb = NULL;




53,845✔





550



  SCMCreateTopicReq createTopicReq = {0};




53,845✔





551












552



  PRINT_LOG_START




53,845✔





553



  if (tDeserializeSCMCreateTopicReq(pReq->pCont, pReq->contLen, &createTopicReq) != 0) {




53,845✔





554



    code = TSDB_CODE_INVALID_MSG;




×







555



    goto END;




×







556



  }










557












558



  mInfo("topic:%s start to create, sql:%s", createTopicReq.name, createTopicReq.sql);




53,845✔





559












560



  MND_TMQ_RETURN_CHECK(mndCheckCreateTopicReq(&createTopicReq));




53,845✔





561












562



  code = mndAcquireTopic(pMnode, createTopicReq.name, &pTopic);




53,845✔





563



  if (code == TSDB_CODE_SUCCESS) {




53,845✔





564



    if (createTopicReq.igExists) {




235✔





565



      mInfo("topic:%s already exist, ignore exist is set", createTopicReq.name);




235✔





566



      goto END;




235✔





567



    } else {










568



      code = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;




×







569



      goto END;




×







570



    }










571



  } else if (code != TSDB_CODE_MND_TOPIC_NOT_EXIST) {




53,610✔





572



    goto END;




×







573



  }










574












575



  pDb = mndAcquireDb(pMnode, createTopicReq.subDbName);




53,610✔





576



  MND_TMQ_NULL_CHECK(pDb);




53,610✔





577












578



  if (pDb->cfg.walRetentionPeriod == 0) {




52,682✔





579



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×







580



    mError("db:%s, not allowed to create topic when WAL_RETENTION_PERIOD is zero", pDb->name);




×







581



    goto END;




×







582



  }










583












584



  if (sdbGetSize(pMnode->pSdb, SDB_TOPIC) >= tmqMaxTopicNum){




52,682✔





585



    code = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;




477✔





586



    mError("topic num out of range");




477✔





587



    goto END;




477✔





588



  }










589












590



  MND_TMQ_RETURN_CHECK(grantCheck(TSDB_GRANT_SUBSCRIPTION));




52,205✔





591



  code = mndCreateTopic(pMnode, pReq, &createTopicReq, pDb, pReq->info.conn.user);




52,205✔





592



  if (code == 0) {




52,205✔





593



    code = TSDB_CODE_ACTION_IN_PROGRESS;




×







594



  }










595












596



  {










597



    SName dbname = {0};




52,205✔





598



    int32_t ret = tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB);




52,205✔





599



    if (ret != 0){




52,205✔





600



      mError("failed to parse db name:%s, ret:%d", createTopicReq.subDbName, ret);




×







601



    }










602



    SName topicName = {0};




52,205✔





603



    ret = tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);




52,205✔





604



    if (ret != 0){




52,205✔





605



      mError("failed to parse topic name:%s, ret:%d", createTopicReq.name, ret);




501✔





606



    }










607



    auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname,




52,205✔





608



                createTopicReq.sql, strlen(createTopicReq.sql));




52,205✔





609



  }










610












611



END:




53,845✔





612



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {




53,845✔





613



    mError("failed to create topic:%s since %s", createTopicReq.name, tstrerror(code));




4,189✔





614



  }










615












616



  mndReleaseTopic(pMnode, pTopic);




53,845✔





617



  mndReleaseDb(pMnode, pDb);




53,845✔





618












619



  tFreeSCMCreateTopicReq(&createTopicReq);




53,845✔





620



  return code;




53,845✔





621



}










622












623



static int32_t mndDropTopic(SMnode *pMnode, STrans *pTrans, SRpcMsg *pReq, SMqTopicObj *pTopic) {




33,591✔





624



  if (pMnode == NULL || pTrans == NULL || pReq == NULL || pTopic == NULL) {




33,591✔





625



    return TSDB_CODE_INVALID_MSG;




×







626



  }










627



  int32_t code = 0;




33,591✔





628



  SSdbRaw *pCommitRaw = NULL;




33,591✔





629



  MND_TMQ_RETURN_CHECK(mndUserRemoveTopic(pMnode, pTrans, pTopic->name));




33,591✔





630



  pCommitRaw = mndTopicActionEncode(pTopic);




33,591✔





631



  MND_TMQ_NULL_CHECK(pCommitRaw);




33,591✔





632



  code = mndTransAppendCommitlog(pTrans, pCommitRaw);




33,591✔





633



  if(code != 0) {




33,591✔





634



    sdbFreeRaw(pCommitRaw);




×







635



    goto END;




×







636



  }










637



  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));




33,591✔





638



  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));




33,591✔





639












640



END:




33,591✔





641



  return code;




33,591✔





642



}










643












644



bool checkTopic(SArray *topics, char *topicName){




34,926✔





645



  if (topics == NULL || topicName == NULL) {




34,926✔





646



    return false;




×







647



  }










648



  int32_t sz = taosArrayGetSize(topics);




34,926✔





649



  for (int32_t i = 0; i < sz; i++) {




35,411✔





650



    char *name = taosArrayGetP(topics, i);




1,028✔





651



    if (name && strcmp(name, topicName) == 0) {




1,028✔





652



      return true;




543✔





653



    }










654



  }










655



  return false;




34,383✔





656



}










657












658



static int32_t mndCheckConsumerByTopic(SMnode *pMnode, STrans *pTrans, char *topicName, bool deleteConsumer){




33,591✔





659



  if (pMnode == NULL || pTrans == NULL || topicName == NULL) {




33,591✔





660



    return TSDB_CODE_INVALID_MSG;




×







661



  }










662



  int32_t         code = 0;




33,591✔





663



  SSdb           *pSdb    = pMnode->pSdb;




33,591✔





664



  void           *pIter = NULL;




33,591✔





665



  SMqConsumerObj *pConsumer = NULL;




33,591✔





666



  SMqConsumerObj *pConsumerNew = NULL;




33,591✔





667












668



  while (1) {




11,577✔





669



    pIter = sdbFetch(pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer);




45,168✔





670



    if (pIter == NULL) {




45,168✔





671



      break;




33,591✔





672



    }










673












674



    bool found1 = checkTopic(pConsumer->assignedTopics, topicName);




11,577✔





675



    bool found2 = checkTopic(pConsumer->rebRemovedTopics, topicName);




11,577✔





676



    bool found3 = checkTopic(pConsumer->rebNewTopics, topicName);




11,577✔





677



    if (found1 || found2 || found3) {




11,577✔





678



      if (deleteConsumer) {




502✔





679



        MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL, &pConsumerNew));




502✔





680



        MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew));




502✔





681



        tDeleteSMqConsumerObj(pConsumerNew);




502✔





682



        pConsumerNew = NULL;




502✔





683



      } else {










684



        mError("topic:%s, failed to drop since subscribed by consumer:0x%" PRIx64 ", in consumer group %s",




×







685



               topicName, pConsumer->consumerId, pConsumer->cgroup);










686



        code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;




×







687



        goto END;




×







688



      }










689



    }










690












691



    sdbRelease(pSdb, pConsumer);




11,577✔





692



  }










693












694



END:




33,591✔





695



  tDeleteSMqConsumerObj(pConsumerNew);




33,591✔





696



  sdbRelease(pSdb, pConsumer);




33,591✔





697



  sdbCancelFetch(pSdb, pIter);




33,591✔





698



  return code;




33,591✔





699



}










700












701



static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic){




2,061✔





702



  if (pMnode == NULL || pTrans == NULL || pTopic == NULL) {




2,061✔





703



    return TSDB_CODE_INVALID_MSG;




×







704



  }










705



  // broadcast to all vnode










706



  void   *pIter = NULL;




2,061✔





707



  SVgObj *pVgroup = NULL;




2,061✔





708



  int32_t code    = 0;




2,061✔





709



  SSdb   *pSdb    = pMnode->pSdb;




2,061✔





710



  void   *buf     = NULL;




2,061✔





711



  while (1) {




8,188✔





712



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




10,249✔





713



    if (pIter == NULL) break;




10,249✔





714



    if (pVgroup->mountVgId) {




8,188✔





715



      sdbRelease(pSdb, pVgroup);




×







716



      continue;




×







717



    }










718



    if (!mndVgroupInDb(pVgroup, pTopic->dbUid)) {




8,188✔





719



      sdbRelease(pSdb, pVgroup);




4,418✔





720



      continue;




4,418✔





721



    }










722












723



    buf = taosMemoryCalloc(1, sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN);




3,770✔





724



    MND_TMQ_NULL_CHECK(buf);




3,770✔





725



    void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));




3,770✔





726



    ((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId);




3,770✔





727



    (void)memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN);




3,770✔





728












729



    STransAction action = {0};




3,770✔





730



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




3,770✔





731



    action.pCont = buf;




3,770✔





732



    action.contLen = sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN;




3,770✔





733



    action.msgType = TDMT_VND_TMQ_DEL_CHECKINFO;




3,770✔





734



    code = mndTransAppendRedoAction(pTrans, &action);




3,770✔





735



    if (code != 0) {




3,770✔





736



      taosMemoryFree(buf);




×







737



      goto END;




×







738



    }










739



    sdbRelease(pSdb, pVgroup);




3,770✔





740



  }










741












742



END:




2,061✔





743



  sdbRelease(pSdb, pVgroup);




2,061✔





744



  sdbCancelFetch(pSdb, pIter);




2,061✔





745



  return code;




2,061✔





746



}










747












748



static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {




39,208✔





749



  if (pReq == NULL) {




39,208✔





750



    return TSDB_CODE_INVALID_MSG;




×







751



  }










752



  SMnode        *pMnode  = pReq->info.node;




39,208✔





753



  SMDropTopicReq dropReq = {0};




39,208✔





754



  int32_t        code = 0;




39,208✔





755



  SMqTopicObj *pTopic = NULL;




39,208✔





756



  STrans      *pTrans = NULL;




39,208✔





757












758



  PRINT_LOG_START




39,208✔





759



  if (tDeserializeSMDropTopicReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {




39,208✔





760



    return TSDB_CODE_INVALID_MSG;




×







761



  }










762












763



  code = mndAcquireTopic(pMnode, dropReq.name, &pTopic);




39,208✔





764



  if (code != 0) {




39,208✔





765



    if (dropReq.igNotExists) {




2,409✔





766



      mInfo("topic:%s, not exist, ignore not exist is set", dropReq.name);




2,409✔





767



      tFreeSMDropTopicReq(&dropReq);




2,409✔





768



      return 0;




2,409✔





769



    } else {










770



      mError("topic:%s, failed to drop since %s", dropReq.name, tstrerror(code));




×







771



      tFreeSMDropTopicReq(&dropReq);




×







772



      return code;




×







773



    }










774



  }










775












776



  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-topic");




36,799✔





777



  MND_TMQ_NULL_CHECK(pTrans);




36,799✔





778












779



  mndTransSetDbName(pTrans, pTopic->db, NULL);




36,799✔





780



  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));




36,799✔





781



  mInfo("trans:%d, used to drop topic:%s, force:%d", pTrans->id, pTopic->name, dropReq.force);




36,799✔





782












783



  MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic));




36,799✔





784



  MND_TMQ_RETURN_CHECK(mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db));




33,591✔





785



  MND_TMQ_RETURN_CHECK(mndCheckConsumerByTopic(pMnode, pTrans, dropReq.name, dropReq.force));




33,591✔





786



  MND_TMQ_RETURN_CHECK(mndDropSubByTopic(pMnode, pTrans, dropReq.name, dropReq.force));




33,591✔





787












788



  if (pTopic->ntbUid != 0) {




33,591✔





789



    MND_TMQ_RETURN_CHECK(mndDropCheckInfoByTopic(pMnode, pTrans, pTopic));




2,061✔





790



  }










791












792



  code = mndDropTopic(pMnode, pTrans, pReq, pTopic);




33,591✔





793












794



END:




36,799✔





795



  mndReleaseTopic(pMnode, pTopic);




36,799✔





796



  mndTransDrop(pTrans);




36,799✔





797



  if (code != 0) {




36,799✔





798



    mError("topic:%s, failed to drop since %s", dropReq.name, tstrerror(code));




3,208✔





799



    tFreeSMDropTopicReq(&dropReq);




3,208✔





800



    return code;




3,208✔





801



  }










802












803



  SName name = {0};




33,591✔





804



  int32_t ret = tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);




33,591✔





805



  if (ret != 0) {




33,591✔





806



    mError("topic:%s, failed to drop since %s", dropReq.name, tstrerror(ret));




382✔





807



  }










808



  auditRecord(pReq, pMnode->clusterId, "dropTopic", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen);




33,591✔





809












810



  tFreeSMDropTopicReq(&dropReq);




33,591✔





811












812



  return TSDB_CODE_ACTION_IN_PROGRESS;




33,591✔





813



}










814












815



int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {




140,006✔





816



  if (pMnode == NULL || dbName == NULL || pNumOfTopics == NULL) {




140,006✔





817



    return TSDB_CODE_INVALID_MSG;




×







818



  }










819



  *pNumOfTopics = 0;




140,006✔





820












821



  SSdb   *pSdb = pMnode->pSdb;




140,006✔





822



  SDbObj *pDb = mndAcquireDb(pMnode, dbName);




140,006✔





823



  if (pDb == NULL) {




140,006✔





824



    return TSDB_CODE_MND_DB_NOT_SELECTED;




×







825



  }










826












827



  int32_t numOfTopics = 0;




140,006✔





828



  void   *pIter = NULL;




140,006✔





829



  while (1) {




×







830



    SMqTopicObj *pTopic = NULL;




140,006✔





831



    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);




140,006✔





832



    if (pIter == NULL) {




140,006✔





833



      break;




140,006✔





834



    }










835












836



    if (pTopic->dbUid == pDb->uid) {




×







837



      numOfTopics++;




×







838



    }










839












840



    sdbRelease(pSdb, pTopic);




×







841



  }










842












843



  *pNumOfTopics = numOfTopics;




140,006✔





844



  mndReleaseDb(pMnode, pDb);




140,006✔





845



  return 0;




140,006✔





846



}










847












848



static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){




34,941✔





849



  if (schema == NULL || schemaJson == NULL) {




34,941✔





850



    return;




×







851



  }










852



  char*   string = NULL;




34,941✔





853



  int32_t code = 0;




34,941✔





854



  cJSON* columns = cJSON_CreateArray();




34,941✔





855



  MND_TMQ_NULL_CHECK(columns);




34,941✔





856



  for (int i = 0; i < nCols; i++) {




379,696✔





857



    cJSON*   column = cJSON_CreateObject();




344,755✔





858



    MND_TMQ_NULL_CHECK(column);




344,755✔





859



    SSchema* s = schema + i;




344,755✔





860



    cJSON*   cname = cJSON_CreateString(s->name);




344,755✔





861



    MND_TMQ_NULL_CHECK(cname);




344,755✔





862



    if (!cJSON_AddItemToObject(column, "name", cname)) {




344,755✔





863



      return;




×







864



    }










865



    cJSON* ctype = cJSON_CreateString(tDataTypes[s->type].name);




344,755✔





866



    MND_TMQ_NULL_CHECK(ctype);




344,755✔





867



    if (!cJSON_AddItemToObject(column, "type", ctype)) {




344,755✔





868



      return;




×







869



    }










870



    int32_t length = 0;




344,755✔





871



    if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY ||




344,755✔





872



        s->type == TSDB_DATA_TYPE_GEOMETRY) {




280,436✔





873



      length = s->bytes - VARSTR_HEADER_SIZE;




72,161✔





874



    } else if (s->type == TSDB_DATA_TYPE_NCHAR || s->type == TSDB_DATA_TYPE_JSON) {




272,594✔





875



      length = (s->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;




28,478✔





876



    } else{










877



      length = s->bytes;




244,116✔





878



    }










879



    cJSON*  cbytes = cJSON_CreateNumber(length);




344,755✔





880



    MND_TMQ_NULL_CHECK(cbytes);




344,755✔





881



    if (!cJSON_AddItemToObject(column, "length", cbytes)){




344,755✔





882



      return;




×







883



    }










884



    if (!cJSON_AddItemToArray(columns, column)){




344,755✔





885



      return;




×







886



    }










887



  }










888



  string = cJSON_PrintUnformatted(columns);




34,941✔





889



  cJSON_Delete(columns);




34,941✔





890












891



  size_t len = strlen(string);




34,941✔





892



  if(string && len <= TSDB_SHOW_SCHEMA_JSON_LEN){




34,941✔





893



    STR_TO_VARSTR(schemaJson, string);




34,941✔





894



  }else{










895



    mError("mndRetrieveTopic build schema error json:%p, json len:%zu", string, len);




×







896



  }










897



  taosMemoryFree(string);




34,941✔





898












899



END:




34,941✔





900



  return;




34,941✔





901



}










902












903



static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {




26,311✔





904



  if (pReq == NULL || pShow == NULL || pBlock == NULL) {




26,311✔





905



    return TSDB_CODE_INVALID_MSG;




×







906



  }










907



  SMnode      *pMnode = pReq->info.node;




26,311✔





908



  SSdb        *pSdb = pMnode->pSdb;




26,311✔





909



  int32_t      numOfRows = 0;




26,311✔





910



  SMqTopicObj *pTopic = NULL;




26,311✔





911



  int32_t      code = 0;




26,311✔





912



  char        *sql  = NULL;




26,311✔





913



  char        *schemaJson  = NULL;




26,311✔





914












915



  while (numOfRows < rowsCapacity) {




62,858✔





916



    pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic);




62,858✔





917



    if (pShow->pIter == NULL) break;




62,858✔





918












919



    SColumnInfoData *pColInfo= NULL;




36,547✔





920



    SName            n = {0};




36,547✔





921



    int32_t          cols = 0;




36,547✔





922












923



    char        topicName[TSDB_TOPIC_NAME_LEN + VARSTR_HEADER_SIZE + 5] = {0};




36,547✔





924



    const char *pName = mndGetDbStr(pTopic->name);




36,547✔





925



    STR_TO_VARSTR(topicName, pName);




36,547✔





926












927



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





928



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





929



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false));




36,547✔





930












931



    char dbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




36,547✔





932



    MND_TMQ_RETURN_CHECK(tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB));




36,547✔





933



    MND_TMQ_RETURN_CHECK(tNameGetDbName(&n, varDataVal(dbName)));




36,547✔





934



    varDataSetLen(dbName, strlen(varDataVal(dbName)));




36,547✔





935












936



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





937



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





938



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false));




36,547✔





939












940



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





941



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





942



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false));




36,547✔





943












944



    sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE);




36,547✔





945



    MND_TMQ_NULL_CHECK(sql);




36,547✔





946



    STR_TO_VARSTR(sql, pTopic->sql);




36,547✔





947












948



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





949



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





950



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)sql, false));




36,547✔





951












952



    taosMemoryFreeClear(sql);




36,547✔





953












954



    schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);




36,547✔





955



    MND_TMQ_NULL_CHECK(schemaJson);




36,547✔





956



    if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){




36,547✔





957



      schemaToJson(pTopic->schema.pSchema, pTopic->schema.nCols, schemaJson);




34,718✔





958



    }else if(pTopic->subType == TOPIC_SUB_TYPE__TABLE){




1,829✔





959



      SStbObj *pStb = mndAcquireStb(pMnode, pTopic->stbName);




223✔





960



      if (pStb == NULL) {




223✔





961



        STR_TO_VARSTR(schemaJson, "NULL");




×







962



        mError("mndRetrieveTopic mndAcquireStb null stbName:%s", pTopic->stbName);




×







963



      }else{










964



        schemaToJson(pStb->pColumns, pStb->numOfColumns, schemaJson);




223✔





965



        mndReleaseStb(pMnode, pStb);




223✔





966



      }










967



    }else{










968



      STR_TO_VARSTR(schemaJson, "NULL");




1,606✔





969



    }










970












971



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





972



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





973



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false));




36,547✔





974



    taosMemoryFreeClear(schemaJson);




36,547✔





975












976



    char mete[4 + VARSTR_HEADER_SIZE] = {0};




36,547✔





977



    if(pTopic->withMeta){




36,547✔





978



      STR_TO_VARSTR(mete, "yes");




120✔





979



    }else{










980



      STR_TO_VARSTR(mete, "no");




36,427✔





981



    }










982












983



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





984



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





985



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)mete, false));




36,547✔





986












987



    char type[8 + VARSTR_HEADER_SIZE] = {0};




36,547✔





988



    if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){




36,547✔





989



      STR_TO_VARSTR(type, "column");




34,718✔





990



    }else if(pTopic->subType == TOPIC_SUB_TYPE__TABLE){




1,829✔





991



      STR_TO_VARSTR(type, "stable");




223✔





992



    }else{










993



      STR_TO_VARSTR(type, "db");




1,606✔





994



    }










995












996



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




36,547✔





997



    MND_TMQ_NULL_CHECK(pColInfo);




36,547✔





998



    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)type, false));




36,547✔





999












1000



    numOfRows++;




36,547✔





1001



    sdbRelease(pSdb, pTopic);




36,547✔





1002



  }










1003












1004



  pShow->numOfRows += numOfRows;




26,311✔





1005



  return numOfRows;




26,311✔





1006












1007



END:




×







1008



  taosMemoryFreeClear(schemaJson);




×







1009



  taosMemoryFreeClear(sql);




×







1010



  return code;




×







1011



}










1012












1013



static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {




×







1014



  if (pMnode == NULL) return;




×







1015



  SSdb *pSdb = pMnode->pSdb;




×







1016



  sdbCancelFetchByType(pSdb, pIter, SDB_TOPIC);




×







1017



}










1018












1019



bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb) {




730,098✔





1020



  if (pMnode == NULL || pDb == NULL) {




730,098✔





1021



    return false;




×







1022



  }










1023



  SSdb        *pSdb = pMnode->pSdb;




730,098✔





1024



  void        *pIter = NULL;




730,098✔





1025



  SMqTopicObj *pTopic = NULL;




730,098✔





1026












1027



  while (1) {










1028



    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);




733,556✔





1029



    if (pIter == NULL) {




733,556✔





1030



      break;




729,979✔





1031



    }










1032












1033



    if (pTopic->dbUid == pDb->uid) {




3,577✔





1034



      sdbRelease(pSdb, pTopic);




119✔





1035



      sdbCancelFetch(pSdb, pIter);




119✔





1036



      return true;




119✔





1037



    }










1038












1039



    sdbRelease(pSdb, pTopic);




3,458✔





1040



  }










1041












1042



  return false;




729,979✔





1043



}
























    

  • 

    •