taosdata / TDengine / #3798

coverage: 9.424% (-20.9%) from 30.372%
#3798

push

travis-ci

happyguoxy 
test:add test cases

21549 of 307601 branches covered (7.01%)

Branch coverage included in aggregate %.

36084 of 303967 relevant lines covered (11.87%)

58620.7 hits per line

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

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




×







48



  SSdbTable table = {




×







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





×







59



    return TSDB_CODE_INVALID_PARA;




×







60



  }










61



  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CREATE_TOPIC, mndProcessCreateTopicReq);




×







62



  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_DROP_TOPIC, mndProcessDropTopicReq);




×







63



  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_ADD_CHECKINFO_RSP, mndTransProcessRsp);




×







64



  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_DEL_CHECKINFO_RSP, mndTransProcessRsp);




×







65












66



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndRetrieveTopic);




×







67



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndCancelGetNextTopic);




×







68












69



  return sdbSetTable(pMnode->pSdb, table);




×







70



}










71












72



void mndCleanupTopic(SMnode *pMnode) {}




×







73












74



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




×







75



  if (fullTopic == NULL) {





×







76



    return;




×







77



  }










78



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




×







79



  if (tmp == NULL) {





×







80



    tstrncpy(topic, fullTopic, TSDB_TOPIC_FNAME_LEN);




×







81



  }else {










82



    tstrncpy(topic, tmp+1, TSDB_TOPIC_FNAME_LEN);




×







83



  }










84



}










85












86



SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {




×







87



  if (pTopic == NULL) {





×







88



    return NULL;




×







89



  }










90



  int32_t code = 0;




×







91



  int32_t lino = 0;




×







92



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







93












94



  void   *swBuf = NULL;




×







95



  int32_t physicalPlanLen = 0;




×







96



  if (pTopic->physicalPlan) {





×







97



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




×







98



  }










99












100



  int32_t schemaLen = 0;




×







101



  if (pTopic->schema.nCols) {





×







102



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




×







103



  }










104



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




×







105












106



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




×







107



                 MND_TOPIC_RESERVE_SIZE;










108



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




×







109



  if (pRaw == NULL) {





×







110



    goto TOPIC_ENCODE_OVER;




×







111



  }










112












113



  int32_t dataPos = 0;




×







114



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





×







115



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





×







116



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





×







117



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





×







118



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





×







119



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





×







120



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





×







121



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





×







122



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





×







123



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





×







124












125



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





×







126



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





×







127



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





×







128



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





×







129



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





×







130












131



  if (pTopic->astLen) {





×







132



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





×







133



  }










134



  SDB_SET_INT32(pRaw, dataPos, physicalPlanLen, TOPIC_ENCODE_OVER);





×







135



  if (physicalPlanLen) {





×







136



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





×







137



  }










138



  SDB_SET_INT32(pRaw, dataPos, schemaLen, TOPIC_ENCODE_OVER);





×







139



  if (schemaLen) {





×







140



    swBuf = taosMemoryMalloc(schemaLen);





×







141



    if (swBuf == NULL) {





×







142



      goto TOPIC_ENCODE_OVER;




×







143



    }










144



    void *aswBuf = swBuf;




×







145



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





×







146



      goto TOPIC_ENCODE_OVER;




×







147



    }










148



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





×







149



  }










150












151



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





×







152



  if (pTopic->ntbUid != 0) {





×







153



    int32_t sz = taosArrayGetSize(pTopic->ntbColIds);




×







154



    SDB_SET_INT32(pRaw, dataPos, sz, TOPIC_ENCODE_OVER);





×







155



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





×







156



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




×







157



      SDB_SET_INT16(pRaw, dataPos, colId, TOPIC_ENCODE_OVER);





×







158



    }










159



  }










160












161



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





×







162












163



  SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_ENCODE_OVER);





×







164



  SDB_SET_DATALEN(pRaw, dataPos, TOPIC_ENCODE_OVER);





×







165












166



  terrno = TSDB_CODE_SUCCESS;




×







167












168



TOPIC_ENCODE_OVER:




×







169



  if (swBuf) taosMemoryFree(swBuf);





×







170



  if (terrno != TSDB_CODE_SUCCESS) {





×







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





×







177



  return pRaw;




×







178



}










179












180



SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {




×







181



  if (pRaw == NULL) return NULL;





×







182



  int32_t code = 0;




×







183



  int32_t lino = 0;




×







184



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







185



  SSdbRow     *pRow = NULL;




×







186



  SMqTopicObj *pTopic = NULL;




×







187



  void        *buf = NULL;




×







188












189



  int8_t sver = 0;




×







190



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





×







191












192



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





×







193



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







194



    goto TOPIC_DECODE_OVER;




×







195



  }










196












197



  pRow = sdbAllocRow(sizeof(SMqTopicObj));




×







198



  if (pRow == NULL) goto TOPIC_DECODE_OVER;





×







199












200



  pTopic = sdbGetRowObj(pRow);




×







201



  if (pTopic == NULL) goto TOPIC_DECODE_OVER;





×







202












203



  int32_t len = 0;




×







204



  int32_t dataPos = 0;




×







205



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





×







206



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





×







207



  if (sver >= 2) {





×







208



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





×







209



  }










210



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





×







211



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





×







212



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





×







213



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





×







214



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





×







215



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





×







216



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





×







217












218



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





×







219



  if (sver >= 3) {





×







220



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





×







221



  }










222



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





×







223



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





×







224



  if (pTopic->sql == NULL) {





×







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





×







229












230



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





×







231



  if (pTopic->astLen) {





×







232



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





×







233



    if (pTopic->ast == NULL) {





×







234



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







235



      goto TOPIC_DECODE_OVER;




×







236



    }










237



  } else {










238



    pTopic->ast = NULL;




×







239



  }










240



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





×







241



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





×







242



  if (len) {





×







243



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





×







244



    if (pTopic->physicalPlan == NULL) {





×







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





×







249



  } else {










250



    pTopic->physicalPlan = NULL;




×







251



  }










252












253



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





×







254



  if (len) {





×







255



    buf = taosMemoryMalloc(len);





×







256



    if (buf == NULL) {





×







257



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







258



      goto TOPIC_DECODE_OVER;




×







259



    }










260



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





×







261



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





×







262



      goto TOPIC_DECODE_OVER;




×







263



    }










264



  } else {










265



    pTopic->schema.nCols = 0;




×







266



    pTopic->schema.version = 0;




×







267



    pTopic->schema.pSchema = NULL;




×







268



  }










269



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





×







270



  if (pTopic->ntbUid != 0) {





×







271



    int32_t ntbColNum;










272



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





×







273



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




×







274



    if (pTopic->ntbColIds == NULL) {





×







275



      terrno = TSDB_CODE_OUT_OF_MEMORY;




×







276



      goto TOPIC_DECODE_OVER;




×







277



    }










278



    int16_t colId;










279



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





×







280



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





×







281



      goto TOPIC_DECODE_OVER;




×







282



    }










283



  }










284












285



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





×







286



  SDB_GET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_DECODE_OVER);





×







287



  terrno = TSDB_CODE_SUCCESS;




×







288












289



TOPIC_DECODE_OVER:




×







290



  taosMemoryFreeClear(buf);





×







291



  if (terrno != TSDB_CODE_SUCCESS) {





×







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





×







298



  return pRow;




×







299



}










300












301



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




×







302



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





×







303



  return 0;




×







304



}










305












306



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




×







307



  if (pTopic == NULL) return 0;





×







308



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





×







309



  taosMemoryFreeClear(pTopic->sql);





×







310



  taosMemoryFreeClear(pTopic->ast);





×







311



  taosMemoryFreeClear(pTopic->physicalPlan);





×







312



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





×







313



  taosArrayDestroy(pTopic->ntbColIds);




×







314



  return 0;




×







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




×







327



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





×







328



    return TSDB_CODE_INVALID_PARA;




×







329



  }










330



  SSdb        *pSdb = pMnode->pSdb;




×







331



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




×







332



  if (*pTopic == NULL) {





×







333



    return TSDB_CODE_MND_TOPIC_NOT_EXIST;




×







334



  }










335



  return TDB_CODE_SUCCESS;




×







336



}










337












338



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




×







339



  if (pMnode == NULL) return;





×







340



  SSdb *pSdb = pMnode->pSdb;




×







341



  sdbRelease(pSdb, pTopic);




×







342



}










343












344



static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {




×







345



  if (pCreate == NULL) return TSDB_CODE_INVALID_PARA;





×







346



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





×







347












348



  if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {





×







349



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





×







350



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





×







351



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





×







352



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





×







353



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





×







354



  }










355












356



  return 0;




×







357



}










358












359



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




×







360



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





×







361



  SNodeList *pNodeList = NULL;




×







362



  int32_t   code = 0;




×







363



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





×







364



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




×







365



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




×







366



  if (tableType == TSDB_CHILD_TABLE) {





×







367



    pTopic->ctbStbUid = suid;




×







368



  } else if (tableType == TSDB_NORMAL_TABLE) {





×







369



    SNode *pNode = NULL;




×







370



    FOREACH(pNode, pNodeList) {





×







371



      SColumnNode *pCol = (SColumnNode *)pNode;




×







372



      if (pCol->tableType == TSDB_NORMAL_TABLE) {





×







373



        pTopic->ntbUid = pCol->tableId;




×







374



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





×







375



      }










376



    }










377



  }










378



  nodesDestroyList(pNodeList);




×







379












380



END:




×







381



  return code;




×







382



}










383












384



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




×







385



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





×







386



  STqCheckInfo info = {0};




×







387



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




×







388



  info.ntbUid = topicObj->ntbUid;




×







389



  info.colIdList = topicObj->ntbColIds;




×







390



  // broadcast forbid alter info










391



  void   *pIter = NULL;




×







392



  SSdb   *pSdb = pMnode->pSdb;




×







393



  SVgObj *pVgroup = NULL;




×







394



  int32_t code = 0;




×







395



  void   *buf = NULL;




×







396












397



  while (1) {




×







398



    // iterate vg










399



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




×







400



    if (pIter == NULL) break;





×







401



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





×







402



      sdbRelease(pSdb, pVgroup);




×







403



      continue;




×







404



    }










405












406



    // encoder check alter info










407



    int32_t len = 0;




×







408



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





×







409



    if (code != 0) {





×







410



      code = TSDB_CODE_OUT_OF_MEMORY;




×







411



      goto END;




×







412



    }










413



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





×







414



    MND_TMQ_NULL_CHECK(buf);





×







415



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




×







416



    SEncoder encoder = {0};




×







417



    tEncoderInit(&encoder, abuf, len);




×







418



    code = tEncodeSTqCheckInfo(&encoder, &info);




×







419



    if (code < 0) {





×







420



      tEncoderClear(&encoder);




×







421



      goto END;




×







422



    }










423



    tEncoderClear(&encoder);




×







424



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




×







425



    // add redo action










426



    STransAction action = {0};




×







427



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




×







428



    action.pCont = buf;




×







429



    action.contLen = sizeof(SMsgHead) + len;




×







430



    action.msgType = TDMT_VND_TMQ_ADD_CHECKINFO;




×







431



    MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));





×







432



    sdbRelease(pSdb, pVgroup);




×







433



    buf = NULL;




×







434



  }










435












436



END:




×







437



  taosMemoryFree(buf);





×







438



  sdbRelease(pSdb, pVgroup);




×







439



  sdbCancelFetch(pSdb, pIter);




×







440



  return code;




×







441



}










442












443



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




×







444



                              const char *userName) {










445



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





×







446



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





×







447



  STrans *pTrans = NULL;




×







448



  int32_t code = 0;




×







449



  SNode  *pAst = NULL;




×







450



  SQueryPlan *pPlan = NULL;




×







451



  SMqTopicObj topicObj = {0};




×







452












453



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




×







454



  MND_TMQ_NULL_CHECK(pTrans);





×







455



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




×







456



  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));





×







457



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





×







458












459



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




×







460



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




×







461



  tstrncpy(topicObj.createUser, userName, TSDB_USER_LEN);




×







462












463



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





×







464












465



  topicObj.createTime = taosGetTimestampMs();




×







466



  topicObj.updateTime = topicObj.createTime;




×







467



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




×







468



  topicObj.dbUid = pDb->uid;




×







469



  topicObj.version = 1;




×







470



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





×







471



  MND_TMQ_NULL_CHECK(topicObj.sql);





×







472



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




×







473



  topicObj.subType = pCreate->subType;




×







474



  topicObj.withMeta = pCreate->withMeta;




×







475












476



  if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {





×







477



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





×







478



    MND_TMQ_NULL_CHECK(topicObj.ast);





×







479



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




×







480



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





×







481



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





×







482



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




×







483



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





×







484












485



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




×







486



    MND_TMQ_NULL_CHECK(topicObj.ntbColIds);





×







487



    MND_TMQ_RETURN_CHECK(extractTopicTbInfo(pAst, &topicObj));





×







488



    if (topicObj.ntbUid == 0) {





×







489



      taosArrayDestroy(topicObj.ntbColIds);




×







490



      topicObj.ntbColIds = NULL;




×







491



    }










492












493



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





×







494



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





×







495



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





×







496



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




×







497



    MND_TMQ_NULL_CHECK(pStb);





×







498



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




×







499



    topicObj.stbUid = pStb->uid;




×







500



    mndReleaseStb(pMnode, pStb);




×







501



    if(pCreate->ast != NULL){





×







502



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





×







503



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





×







504



      MND_TMQ_NULL_CHECK(topicObj.ast);





×







505



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




×







506



    }










507



  }










508












509



  SSdbRaw *pCommitRaw = mndTopicActionEncode(&topicObj);




×







510



  MND_TMQ_NULL_CHECK(pCommitRaw);





×







511



  code = mndTransAppendCommitlog(pTrans, pCommitRaw);




×







512



  if(code != 0) {





×







513



    sdbFreeRaw(pCommitRaw);




×







514



    goto END;




×







515



  }










516












517



  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×







518



  if (topicObj.ntbUid != 0) {





×







519



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





×







520



  }










521



  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));





×







522



  code = TSDB_CODE_ACTION_IN_PROGRESS;




×







523












524



END:




×







525



  taosMemoryFreeClear(topicObj.physicalPlan);





×







526



  taosMemoryFreeClear(topicObj.sql);





×







527



  taosMemoryFreeClear(topicObj.ast);





×







528



  taosArrayDestroy(topicObj.ntbColIds);




×







529



  if (topicObj.schema.nCols) {





×







530



    taosMemoryFreeClear(topicObj.schema.pSchema);





×







531



  }










532



  nodesDestroyNode(pAst);




×







533



  nodesDestroyNode((SNode *)pPlan);




×







534



  mndTransDrop(pTrans);




×







535



  return code;




×







536



}










537












538



static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {




×







539



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





×







540



    return TSDB_CODE_INVALID_MSG;




×







541



  }










542



  SMnode           *pMnode = pReq->info.node;




×







543



  int32_t           code = TDB_CODE_SUCCESS;




×







544



  SMqTopicObj      *pTopic = NULL;




×







545



  SDbObj           *pDb = NULL;




×







546



  SCMCreateTopicReq createTopicReq = {0};




×







547












548



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





×







549



    code = TSDB_CODE_INVALID_MSG;




×







550



    goto END;




×







551



  }










552












553



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





×







554












555



  MND_TMQ_RETURN_CHECK(mndCheckCreateTopicReq(&createTopicReq));





×







556












557



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




×







558



  if (code == TDB_CODE_SUCCESS) {





×







559



    if (createTopicReq.igExists) {





×







560



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





×







561



      goto END;




×







562



    } else {










563



      code = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;




×







564



      goto END;




×







565



    }










566



  } else if (code != TSDB_CODE_MND_TOPIC_NOT_EXIST) {





×







567



    goto END;




×







568



  }










569












570



  pDb = mndAcquireDb(pMnode, createTopicReq.subDbName);




×







571



  MND_TMQ_NULL_CHECK(pDb);





×







572












573



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





×







574



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×







575



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





×







576



    goto END;




×







577



  }










578












579



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





×







580



    code = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;




×







581



    mError("topic num out of range");





×







582



    goto END;




×







583



  }










584












585



  MND_TMQ_RETURN_CHECK(grantCheck(TSDB_GRANT_SUBSCRIPTION));





×







586



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




×







587



  if (code == 0) {





×







588



    code = TSDB_CODE_ACTION_IN_PROGRESS;




×







589



  }










590












591



  {










592



    SName dbname = {0};




×







593



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




×







594



    if (ret != 0){





×







595



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





×







596



    }










597



    SName topicName = {0};




×







598



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




×







599



    if (ret != 0){





×







600



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





×







601



    }










602



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




×







603



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




×







604



  }










605












606



END:




×







607



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





×







608



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





×







609



  }










610












611



  mndReleaseTopic(pMnode, pTopic);




×







612



  mndReleaseDb(pMnode, pDb);




×







613












614



  tFreeSCMCreateTopicReq(&createTopicReq);




×







615



  return code;




×







616



}










617












618



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




×







619



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





×







620



    return TSDB_CODE_INVALID_MSG;




×







621



  }










622



  int32_t code = 0;




×







623



  SSdbRaw *pCommitRaw = NULL;




×







624



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





×







625



  pCommitRaw = mndTopicActionEncode(pTopic);




×







626



  MND_TMQ_NULL_CHECK(pCommitRaw);





×







627



  code = mndTransAppendCommitlog(pTrans, pCommitRaw);




×







628



  if(code != 0) {





×







629



    sdbFreeRaw(pCommitRaw);




×







630



    goto END;




×







631



  }










632



  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));





×







633



  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));





×







634












635



END:




×







636



  return code;




×







637



}










638












639



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




×







640



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





×







641



    return false;




×







642



  }










643



  int32_t sz = taosArrayGetSize(topics);




×







644



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





×







645



    char *name = taosArrayGetP(topics, i);




×







646



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





×







647



      return true;




×







648



    }










649



  }










650



  return false;




×







651



}










652












653



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




×







654



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





×







655



    return TSDB_CODE_INVALID_MSG;




×







656



  }










657



  int32_t         code = 0;




×







658



  SSdb           *pSdb    = pMnode->pSdb;




×







659



  void           *pIter = NULL;




×







660



  SMqConsumerObj *pConsumer = NULL;




×







661



  SMqConsumerObj *pConsumerNew = NULL;




×







662












663



  while (1) {










664



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




×







665



    if (pIter == NULL) {





×







666



      break;




×







667



    }










668












669



    if (deleteConsumer) {





×







670



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





×







671



      MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew));





×







672



      tDeleteSMqConsumerObj(pConsumerNew);




×







673



      pConsumerNew = NULL;




×







674



    } else {










675



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




×







676



      if (found){





×







677



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





×







678



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










679



        code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;




×







680



        goto END;




×







681



      }










682



    }










683












684



    sdbRelease(pSdb, pConsumer);




×







685



  }










686












687



END:




×







688



  tDeleteSMqConsumerObj(pConsumerNew);




×







689



  sdbRelease(pSdb, pConsumer);




×







690



  sdbCancelFetch(pSdb, pIter);




×







691



  return code;




×







692



}










693












694



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




×







695



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





×







696



    return TSDB_CODE_INVALID_MSG;




×







697



  }










698



  // broadcast to all vnode










699



  void   *pIter = NULL;




×







700



  SVgObj *pVgroup = NULL;




×







701



  int32_t code    = 0;




×







702



  SSdb   *pSdb    = pMnode->pSdb;




×







703



  void   *buf     = NULL;




×







704



  while (1) {




×







705



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




×







706



    if (pIter == NULL) break;





×







707



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





×







708



      sdbRelease(pSdb, pVgroup);




×







709



      continue;




×







710



    }










711












712



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





×







713



    MND_TMQ_NULL_CHECK(buf);





×







714



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




×







715



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




×







716



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




×







717












718



    STransAction action = {0};




×







719



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




×







720



    action.pCont = buf;




×







721



    action.contLen = sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN;




×







722



    action.msgType = TDMT_VND_TMQ_DEL_CHECKINFO;




×







723



    code = mndTransAppendRedoAction(pTrans, &action);




×







724



    if (code != 0) {





×







725



      taosMemoryFree(buf);





×







726



      goto END;




×







727



    }










728



    sdbRelease(pSdb, pVgroup);




×







729



  }










730












731



END:




×







732



  sdbRelease(pSdb, pVgroup);




×







733



  sdbCancelFetch(pSdb, pIter);




×







734



  return code;




×







735



}










736












737



static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {




×







738



  if (pReq == NULL) {





×







739



    return TSDB_CODE_INVALID_MSG;




×







740



  }










741



  SMnode        *pMnode  = pReq->info.node;




×







742



  SMDropTopicReq dropReq = {0};




×







743



  int32_t        code = 0;




×







744



  SMqTopicObj *pTopic = NULL;




×







745



  STrans      *pTrans = NULL;




×







746












747



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





×







748



    return TSDB_CODE_INVALID_MSG;




×







749



  }










750












751



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




×







752



  if (code != 0) {





×







753



    if (dropReq.igNotExists) {





×







754



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





×







755



      tFreeSMDropTopicReq(&dropReq);




×







756



      return 0;




×







757



    } else {










758



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





×







759



      tFreeSMDropTopicReq(&dropReq);




×







760



      return code;




×







761



    }










762



  }










763












764



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




×







765



  MND_TMQ_NULL_CHECK(pTrans);





×







766












767



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




×







768



  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));





×







769



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





×







770












771



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





×







772



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





×







773



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





×







774



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





×







775












776



  if (pTopic->ntbUid != 0) {





×







777



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





×







778



  }










779












780



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




×







781












782



END:




×







783



  mndReleaseTopic(pMnode, pTopic);




×







784



  mndTransDrop(pTrans);




×







785



  if (code != 0) {





×







786



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





×







787



    tFreeSMDropTopicReq(&dropReq);




×







788



    return code;




×







789



  }










790












791



  SName name = {0};




×







792



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




×







793



  if (ret != 0) {





×







794



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





×







795



  }










796



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




×







797












798



  tFreeSMDropTopicReq(&dropReq);




×







799












800



  return TSDB_CODE_ACTION_IN_PROGRESS;




×







801



}










802












803



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




×







804



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





×







805



    return TSDB_CODE_INVALID_MSG;




×







806



  }










807



  *pNumOfTopics = 0;




×







808












809



  SSdb   *pSdb = pMnode->pSdb;




×







810



  SDbObj *pDb = mndAcquireDb(pMnode, dbName);




×







811



  if (pDb == NULL) {





×







812



    return TSDB_CODE_MND_DB_NOT_SELECTED;




×







813



  }










814












815



  int32_t numOfTopics = 0;




×







816



  void   *pIter = NULL;




×







817



  while (1) {




×







818



    SMqTopicObj *pTopic = NULL;




×







819



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




×







820



    if (pIter == NULL) {





×







821



      break;




×







822



    }










823












824



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





×







825



      numOfTopics++;




×







826



    }










827












828



    sdbRelease(pSdb, pTopic);




×







829



  }










830












831



  *pNumOfTopics = numOfTopics;




×







832



  mndReleaseDb(pMnode, pDb);




×







833



  return 0;




×







834



}










835












836



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




×







837



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





×







838



    return;




×







839



  }










840



  char*   string = NULL;




×







841



  int32_t code = 0;




×







842



  cJSON* columns = cJSON_CreateArray();




×







843



  MND_TMQ_NULL_CHECK(columns);





×







844



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





×







845



    cJSON*   column = cJSON_CreateObject();




×







846



    MND_TMQ_NULL_CHECK(column);





×







847



    SSchema* s = schema + i;




×







848



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




×







849



    MND_TMQ_NULL_CHECK(cname);





×







850



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





×







851



      return;




×







852



    }










853



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




×







854



    MND_TMQ_NULL_CHECK(ctype);





×







855



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





×







856



      return;




×







857



    }










858



    int32_t length = 0;




×







859



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





×







860



        s->type == TSDB_DATA_TYPE_GEOMETRY) {





×







861



      length = s->bytes - VARSTR_HEADER_SIZE;




×







862



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





×







863



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




×







864



    } else{










865



      length = s->bytes;




×







866



    }










867



    cJSON*  cbytes = cJSON_CreateNumber(length);




×







868



    MND_TMQ_NULL_CHECK(cbytes);





×







869



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





×







870



      return;




×







871



    }










872



    if (!cJSON_AddItemToArray(columns, column)){





×







873



      return;




×







874



    }










875



  }










876



  string = cJSON_PrintUnformatted(columns);




×







877



  cJSON_Delete(columns);




×







878












879



  size_t len = strlen(string);




×







880



  if(string && len <= TSDB_SHOW_SCHEMA_JSON_LEN){





×







881



    STR_TO_VARSTR(schemaJson, string);




×







882



  }else{










883



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





×







884



  }










885



  taosMemoryFree(string);





×







886












887



END:




×







888



  return;




×







889



}










890












891



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




×







892



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





×







893



    return TSDB_CODE_INVALID_MSG;




×







894



  }










895



  SMnode      *pMnode = pReq->info.node;




×







896



  SSdb        *pSdb = pMnode->pSdb;




×







897



  int32_t      numOfRows = 0;




×







898



  SMqTopicObj *pTopic = NULL;




×







899



  int32_t      code = 0;




×







900



  char        *sql  = NULL;




×







901



  char        *schemaJson  = NULL;




×







902












903



  while (numOfRows < rowsCapacity) {





×







904



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




×







905



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





×







906












907



    SColumnInfoData *pColInfo= NULL;




×







908



    SName            n = {0};




×







909



    int32_t          cols = 0;




×







910












911



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




×







912



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




×







913



    STR_TO_VARSTR(topicName, pName);




×







914












915



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




×







916



    MND_TMQ_NULL_CHECK(pColInfo);





×







917



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





×







918












919



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




×







920



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





×







921



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





×







922



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




×







923












924



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




×







925



    MND_TMQ_NULL_CHECK(pColInfo);





×







926



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





×







927












928



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




×







929



    MND_TMQ_NULL_CHECK(pColInfo);





×







930



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





×







931












932



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





×







933



    MND_TMQ_NULL_CHECK(sql);





×







934



    STR_TO_VARSTR(sql, pTopic->sql);




×







935












936



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




×







937



    MND_TMQ_NULL_CHECK(pColInfo);





×







938



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





×







939












940



    taosMemoryFreeClear(sql);





×







941












942



    schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);





×







943



    MND_TMQ_NULL_CHECK(schemaJson);





×







944



    if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){





×







945



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




×







946



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





×







947



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




×







948



      if (pStb == NULL) {





×







949



        STR_TO_VARSTR(schemaJson, "NULL");




×







950



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





×







951



      }else{










952



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




×







953



        mndReleaseStb(pMnode, pStb);




×







954



      }










955



    }else{










956



      STR_TO_VARSTR(schemaJson, "NULL");




×







957



    }










958












959



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




×







960



    MND_TMQ_NULL_CHECK(pColInfo);





×







961



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





×







962



    taosMemoryFreeClear(schemaJson);





×







963












964



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




×







965



    if(pTopic->withMeta){





×







966



      STR_TO_VARSTR(mete, "yes");




×







967



    }else{










968



      STR_TO_VARSTR(mete, "no");




×







969



    }










970












971



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




×







972



    MND_TMQ_NULL_CHECK(pColInfo);





×







973



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





×







974












975



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




×







976



    if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){





×







977



      STR_TO_VARSTR(type, "column");




×







978



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





×







979



      STR_TO_VARSTR(type, "stable");




×







980



    }else{










981



      STR_TO_VARSTR(type, "db");




×







982



    }










983












984



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




×







985



    MND_TMQ_NULL_CHECK(pColInfo);





×







986



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





×







987












988



    numOfRows++;




×







989



    sdbRelease(pSdb, pTopic);




×







990



  }










991












992



  pShow->numOfRows += numOfRows;




×







993



  return numOfRows;




×







994












995



END:




×







996



  taosMemoryFreeClear(schemaJson);





×







997



  taosMemoryFreeClear(sql);





×







998



  return code;




×







999



}










1000












1001



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




×







1002



  if (pMnode == NULL) return;





×







1003



  SSdb *pSdb = pMnode->pSdb;




×







1004



  sdbCancelFetchByType(pSdb, pIter, SDB_TOPIC);




×







1005



}










1006












1007



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




×







1008



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





×







1009



    return false;




×







1010



  }










1011



  SSdb        *pSdb = pMnode->pSdb;




×







1012



  void        *pIter = NULL;




×







1013



  SMqTopicObj *pTopic = NULL;




×







1014












1015



  while (1) {










1016



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




×







1017



    if (pIter == NULL) {





×







1018



      break;




×







1019



    }










1020












1021



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





×







1022



      sdbRelease(pSdb, pTopic);




×







1023



      sdbCancelFetch(pSdb, pIter);




×







1024



      return true;




×







1025



    }










1026












1027



    sdbRelease(pSdb, pTopic);




×







1028



  }










1029












1030



  return false;




×







1031



}
























    

  • 

    •