taosdata / TDengine / #3621

coverage: 2.037% (-61.5%) from 63.573%
#3621

push

travis-ci

web-flow 
Merge pull request #29874 from taosdata/merge/mainto3.0

merge: from main to 3.0 branch

4357 of 287032 branches covered (1.52%)

Branch coverage included in aggregate %.

0 of 174 new or added lines in 18 files covered. (0.0%)

213359 existing lines in 469 files now uncovered.

7260 of 283369 relevant lines covered (2.56%)

23737.72 hits per line

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

0.0
/source/dnode/mnode/impl/src/mndIndex.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 
 *
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



#define _DEFAULT_SOURCE










17



#include "mndIndex.h"










18



#include "mndDb.h"










19



#include "mndDnode.h"










20



#include "mndIndexComm.h"










21



#include "mndInfoSchema.h"










22



#include "mndMnode.h"










23



#include "mndPrivilege.h"










24



#include "mndScheduler.h"










25



#include "mndShow.h"










26



#include "mndStb.h"










27



#include "mndStream.h"










28



#include "mndTrans.h"










29



#include "mndUser.h"










30



#include "mndVgroup.h"










31



#include "parser.h"










32



#include "tname.h"










33












34



#define TSDB_IDX_VER_NUMBER   1










35



#define TSDB_IDX_RESERVE_SIZE 64










36












37



static SSdbRaw *mndIdxActionEncode(SIdxObj *pSma);










38



static SSdbRow *mndIdxActionDecode(SSdbRaw *pRaw);










39



static int32_t  mndIdxActionInsert(SSdb *pSdb, SIdxObj *pIdx);










40



static int32_t  mndIdxActionDelete(SSdb *pSdb, SIdxObj *pIdx);










41



static int32_t  mndIdxActionUpdate(SSdb *pSdb, SIdxObj *pOld, SIdxObj *pNew);










42



static int32_t  mndProcessCreateIdxReq(SRpcMsg *pReq);










43



// static int32_t  mndProcessDropIdxReq(SRpcMsg *pReq);










44



static int32_t mndProcessGetIdxReq(SRpcMsg *pReq);










45



static int32_t mndProcessGetTbIdxReq(SRpcMsg *pReq);










46



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










47



//  static void    mndCancelGetNextIdx(SMnode *pMnode, void *pIter);










48



static void mndDestroyIdxObj(SIdxObj *pIdxObj);










49












50



static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *req, SDbObj *pDb, SStbObj *pStb);










51













UNCOV

52



int32_t mndInitIdx(SMnode *pMnode) {




×








UNCOV

53



  SSdbTable table = {




×







54



      .sdbType = SDB_IDX,










55



      .keyType = SDB_KEY_BINARY,










56



      .encodeFp = (SdbEncodeFp)mndIdxActionEncode,










57



      .decodeFp = (SdbDecodeFp)mndIdxActionDecode,










58



      .insertFp = (SdbInsertFp)mndIdxActionInsert,










59



      .updateFp = (SdbUpdateFp)mndIdxActionUpdate,










60



      .deleteFp = (SdbDeleteFp)mndIdxActionDelete,










61



  };










62













UNCOV

63



  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_INDEX, mndProcessCreateIdxReq);




×







64



  // mndSetMsgHandle(pMnode, TDMT_MND_DROP_INDEX, mndProcessDropIdxReq);










65













UNCOV

66



  mndSetMsgHandle(pMnode, TDMT_VND_CREATE_INDEX_RSP, mndTransProcessRsp);




×








UNCOV

67



  mndSetMsgHandle(pMnode, TDMT_VND_DROP_INDEX_RSP, mndTransProcessRsp);




×







68












69



  // mndSetMsgHandle(pMnode, TDMT_MND_CREATE_SMA, mndProcessCreateIdxReq);










70



  // mndSetMsgHandle(pMnode, TDMT_MND_DROP_SMA, mndProcessDropIdxReq);










71



  // mndSetMsgHandle(pMnode, TDMT_VND_CREATE_SMA_RSP, mndTransProcessRsp);










72



  // mndSetMsgHandle(pMnode, TDMT_VND_DROP_SMA_RSP, mndTransProcessRsp);










73



  // mndSetMsgHandle(pMnode, TDMT_MND_GET_INDEX, mndProcessGetIdxReq);










74



  // mndSetMsgHandle(pMnode, TDMT_MND_GET_TABLE_INDEX, mndProcessGetTbIdxReq);










75












76



  // type same with sma










77



  // mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndRetrieveIdx);










78



  // mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndCancelGetNextIdx);











UNCOV

79



  return sdbSetTable(pMnode->pSdb, table);




×







80



}










81













UNCOV

82



static int32_t mndFindSuperTableTagId(const SStbObj *pStb, const char *tagName, int8_t *hasIdx) {




×








UNCOV

83



  for (int32_t tag = 0; tag < pStb->numOfTags; tag++) {





×








UNCOV

84



    if (strcasecmp(pStb->pTags[tag].name, tagName) == 0) {





×








UNCOV

85



      if (IS_IDX_ON(&pStb->pTags[tag])) {





×








UNCOV

86



        *hasIdx = 1;




×







87



      }











UNCOV

88



      return tag;




×







89



    }










90



  }










91












92



  return TSDB_CODE_MND_TAG_NOT_EXIST;




×







93



}










94













UNCOV

95



int mndSetCreateIdxRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb, SIdxObj *pIdx) {




×








UNCOV

96



  int32_t code = 0;




×








UNCOV

97



  SSdb   *pSdb = pMnode->pSdb;




×








UNCOV

98



  SVgObj *pVgroup = NULL;




×








UNCOV

99



  void   *pIter = NULL;




×







100



  int32_t contLen;










101













UNCOV

102



  while (1) {




×








UNCOV

103



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




×








UNCOV

104



    if (pIter == NULL) break;





×








UNCOV

105



    if (!mndVgroupInDb(pVgroup, pDb->uid)) {





×








UNCOV

106



      sdbRelease(pSdb, pVgroup);




×








UNCOV

107



      continue;




×







108



    }










109













UNCOV

110



    void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen, NULL, 0);




×








UNCOV

111



    if (pReq == NULL) {





×







112



      sdbCancelFetch(pSdb, pIter);




×







113



      sdbRelease(pSdb, pVgroup);




×







114



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







115



      if (terrno != 0) code = terrno;





×







116



      TAOS_RETURN(code);




×







117



    }











UNCOV

118



    STransAction action = {0};




×








UNCOV

119



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




×








UNCOV

120



    action.pCont = pReq;




×








UNCOV

121



    action.contLen = contLen;




×








UNCOV

122



    action.msgType = TDMT_VND_CREATE_INDEX;




×








UNCOV

123



    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {





×







124



      taosMemoryFree(pReq);





×







125



      sdbCancelFetch(pSdb, pIter);




×







126



      sdbRelease(pSdb, pVgroup);




×







127



      TAOS_RETURN(code);




×







128



    }











UNCOV

129



    sdbRelease(pSdb, pVgroup);




×







130



  }










131













UNCOV

132



  return 0;




×







133



}











UNCOV

134



static void *mndBuildDropIdxReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStbObj, SIdxObj *pIdx, int32_t *contLen) {




×








UNCOV

135



  int32_t len = 0;




×







136













UNCOV

137



  SDropIndexReq req = {0};




×








UNCOV

138



  memcpy(req.colName, pIdx->colName, sizeof(pIdx->colName));




×








UNCOV

139



  memcpy(req.stb, pIdx->stb, sizeof(pIdx->stb));




×








UNCOV

140



  req.dbUid = pIdx->dbUid;




×








UNCOV

141



  req.stbUid = pIdx->stbUid;




×







142













UNCOV

143



  mInfo("idx: %s start to build drop index req", pIdx->name);





×







144













UNCOV

145



  len = tSerializeSDropIdxReq(NULL, 0, &req);




×








UNCOV

146



  if (len < 0) {





×







147



    goto _err;




×







148



  }










149













UNCOV

150



  len += sizeof(SMsgHead);




×








UNCOV

151



  SMsgHead *pHead = taosMemoryCalloc(1, len);





×








UNCOV

152



  if (pHead == NULL) {





×







153



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







154



    goto _err;




×







155



  }










156













UNCOV

157



  pHead->contLen = htonl(len);




×








UNCOV

158



  pHead->vgId = htonl(pVgroup->vgId);




×







159













UNCOV

160



  void   *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));




×








UNCOV

161



  int32_t ret = 0;




×








UNCOV

162



  if ((ret = tSerializeSDropIdxReq(pBuf, len - sizeof(SMsgHead), &req)) < 0) {





×







163



    terrno = ret;




×







164



    return NULL;




×







165



  }











UNCOV

166



  *contLen = len;




×








UNCOV

167



  return pHead;




×







168



_err:




×







169












170



  return NULL;




×







171



}











UNCOV

172



int mndSetDropIdxRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb, SIdxObj *pIdx) {




×








UNCOV

173



  int32_t code = 0;




×








UNCOV

174



  SSdb   *pSdb = pMnode->pSdb;




×








UNCOV

175



  SVgObj *pVgroup = NULL;




×








UNCOV

176



  void   *pIter = NULL;




×







177



  int32_t contLen;










178













UNCOV

179



  while (1) {




×








UNCOV

180



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




×








UNCOV

181



    if (pIter == NULL) break;





×








UNCOV

182



    if (!mndVgroupInDb(pVgroup, pDb->uid)) {





×








UNCOV

183



      sdbRelease(pSdb, pVgroup);




×








UNCOV

184



      continue;




×







185



    }










186












187



    int32_t len;











UNCOV

188



    void   *pReq = mndBuildDropIdxReq(pMnode, pVgroup, pStb, pIdx, &len);




×








UNCOV

189



    if (pReq == NULL) {





×







190



      sdbCancelFetch(pSdb, pIter);




×







191



      sdbRelease(pSdb, pVgroup);




×







192



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







193



      if (terrno != 0) code = terrno;





×







194



      return code;




×







195



    }











UNCOV

196



    STransAction action = {0};




×








UNCOV

197



    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);




×








UNCOV

198



    action.pCont = pReq;




×








UNCOV

199



    action.contLen = len;




×








UNCOV

200



    action.msgType = TDMT_VND_DROP_INDEX;




×








UNCOV

201



    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {





×







202



      taosMemoryFree(pReq);





×







203



      sdbCancelFetch(pSdb, pIter);




×







204



      sdbRelease(pSdb, pVgroup);




×







205



      return code;




×







206



    }











UNCOV

207



    sdbRelease(pSdb, pVgroup);




×







208



  }










209













UNCOV

210



  TAOS_RETURN(code);




×







211



}










212













UNCOV

213



void mndCleanupIdx(SMnode *pMnode) {




×







214



  // do nothing











UNCOV

215



  return;




×







216



}










217













UNCOV

218



static SSdbRaw *mndIdxActionEncode(SIdxObj *pIdx) {




×








UNCOV

219



  int32_t code = 0;




×








UNCOV

220



  int32_t lino = 0;




×








UNCOV

221



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







222












223



  // int32_t size =










224



  //     sizeof(SSmaObj) + pSma->exprLen + pSma->tagsFilterLen + pSma->sqlLen + pSma->astLen + TSDB_IDX_RESERVE_SIZE;











UNCOV

225



  int32_t size = sizeof(SIdxObj) + TSDB_IDX_RESERVE_SIZE;




×







226













UNCOV

227



  SSdbRaw *pRaw = sdbAllocRaw(SDB_IDX, TSDB_IDX_VER_NUMBER, size);




×








UNCOV

228



  if (pRaw == NULL) goto _OVER;





×







229













UNCOV

230



  int32_t dataPos = 0;




×








UNCOV

231



  SDB_SET_BINARY(pRaw, dataPos, pIdx->name, TSDB_TABLE_FNAME_LEN, _OVER)





×








UNCOV

232



  SDB_SET_BINARY(pRaw, dataPos, pIdx->stb, TSDB_TABLE_FNAME_LEN, _OVER)





×








UNCOV

233



  SDB_SET_BINARY(pRaw, dataPos, pIdx->db, TSDB_DB_FNAME_LEN, _OVER)





×








UNCOV

234



  SDB_SET_BINARY(pRaw, dataPos, pIdx->dstTbName, TSDB_DB_FNAME_LEN, _OVER)





×








UNCOV

235



  SDB_SET_BINARY(pRaw, dataPos, pIdx->colName, TSDB_COL_NAME_LEN, _OVER)





×








UNCOV

236



  SDB_SET_INT64(pRaw, dataPos, pIdx->createdTime, _OVER)





×








UNCOV

237



  SDB_SET_INT64(pRaw, dataPos, pIdx->uid, _OVER)





×








UNCOV

238



  SDB_SET_INT64(pRaw, dataPos, pIdx->stbUid, _OVER)





×








UNCOV

239



  SDB_SET_INT64(pRaw, dataPos, pIdx->dbUid, _OVER)





×







240













UNCOV

241



  SDB_SET_RESERVE(pRaw, dataPos, TSDB_IDX_RESERVE_SIZE, _OVER)





×








UNCOV

242



  SDB_SET_DATALEN(pRaw, dataPos, _OVER)





×







243













UNCOV

244



  terrno = 0;




×







245













UNCOV

246



_OVER:




×








UNCOV

247



  if (terrno != 0) {





×







248



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





×







249



    sdbFreeRaw(pRaw);




×







250



    return NULL;




×







251



  }










252













UNCOV

253



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





×








UNCOV

254



  return pRaw;




×







255



}










256













UNCOV

257



static SSdbRow *mndIdxActionDecode(SSdbRaw *pRaw) {




×








UNCOV

258



  int32_t code = 0;




×








UNCOV

259



  int32_t lino = 0;




×








UNCOV

260



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

261



  SSdbRow *pRow = NULL;




×








UNCOV

262



  SIdxObj *pIdx = NULL;




×







263













UNCOV

264



  int8_t sver = 0;




×








UNCOV

265



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





×







266













UNCOV

267



  if (sver != TSDB_IDX_VER_NUMBER) {





×







268



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







269



    goto _OVER;




×







270



  }










271













UNCOV

272



  pRow = sdbAllocRow(sizeof(SIdxObj));




×








UNCOV

273



  if (pRow == NULL) goto _OVER;





×







274













UNCOV

275



  pIdx = sdbGetRowObj(pRow);




×








UNCOV

276



  if (pIdx == NULL) goto _OVER;





×







277













UNCOV

278



  int32_t dataPos = 0;




×







279













UNCOV

280



  SDB_GET_BINARY(pRaw, dataPos, pIdx->name, TSDB_TABLE_FNAME_LEN, _OVER)





×








UNCOV

281



  SDB_GET_BINARY(pRaw, dataPos, pIdx->stb, TSDB_TABLE_FNAME_LEN, _OVER)





×








UNCOV

282



  SDB_GET_BINARY(pRaw, dataPos, pIdx->db, TSDB_DB_FNAME_LEN, _OVER)





×








UNCOV

283



  SDB_GET_BINARY(pRaw, dataPos, pIdx->dstTbName, TSDB_DB_FNAME_LEN, _OVER)





×








UNCOV

284



  SDB_GET_BINARY(pRaw, dataPos, pIdx->colName, TSDB_COL_NAME_LEN, _OVER)





×








UNCOV

285



  SDB_GET_INT64(pRaw, dataPos, &pIdx->createdTime, _OVER)





×








UNCOV

286



  SDB_GET_INT64(pRaw, dataPos, &pIdx->uid, _OVER)





×








UNCOV

287



  SDB_GET_INT64(pRaw, dataPos, &pIdx->stbUid, _OVER)





×








UNCOV

288



  SDB_GET_INT64(pRaw, dataPos, &pIdx->dbUid, _OVER)





×







289













UNCOV

290



  SDB_GET_RESERVE(pRaw, dataPos, TSDB_IDX_RESERVE_SIZE, _OVER)





×







291













UNCOV

292



  terrno = 0;




×







293













UNCOV

294



_OVER:




×








UNCOV

295



  if (terrno != 0) {





×







296



    taosMemoryFree(pRow);





×







297



    return NULL;




×







298



  }










299













UNCOV

300



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





×








UNCOV

301



  return pRow;




×







302



}










303













UNCOV

304



static int32_t mndIdxActionInsert(SSdb *pSdb, SIdxObj *pIdx) {




×








UNCOV

305



  mTrace("idx:%s, perform insert action, row:%p", pIdx->name, pIdx);





×








UNCOV

306



  return 0;




×







307



}










308













UNCOV

309



static int32_t mndIdxActionDelete(SSdb *pSdb, SIdxObj *pIdx) {




×








UNCOV

310



  mTrace("idx:%s, perform delete action, row:%p", pIdx->name, pIdx);





×








UNCOV

311



  return 0;




×







312



}










313













UNCOV

314



static int32_t mndIdxActionUpdate(SSdb *pSdb, SIdxObj *pOld, SIdxObj *pNew) {




×







315



  // lock no not











UNCOV

316



  if (strncmp(pOld->colName, pNew->colName, TSDB_COL_NAME_LEN) != 0) {





×








UNCOV

317



    memcpy(pOld->colName, pNew->colName, sizeof(pNew->colName));




×







318



  }











UNCOV

319



  mTrace("idx:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);





×








UNCOV

320



  return 0;




×







321



}










322












323



SIdxObj *mndAcquireIdx(SMnode *pMnode, char *idxName) {




×







324



  SSdb    *pSdb = pMnode->pSdb;




×







325



  SIdxObj *pIdx = sdbAcquire(pSdb, SDB_IDX, idxName);




×







326



  if (pIdx == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {





×







327



    terrno = TSDB_CODE_MND_TAG_INDEX_NOT_EXIST;




×







328



  }










329



  return pIdx;




×







330



}










331













UNCOV

332



void mndReleaseIdx(SMnode *pMnode, SIdxObj *pIdx) {




×








UNCOV

333



  SSdb *pSdb = pMnode->pSdb;




×








UNCOV

334



  sdbRelease(pSdb, pIdx);




×








UNCOV

335



}




×







336













UNCOV

337



SDbObj *mndAcquireDbByIdx(SMnode *pMnode, const char *idxName) {




×








UNCOV

338



  SName name = {0};




×








UNCOV

339



  if ((terrno = tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) < 0) return NULL;





×







340













UNCOV

341



  char db[TSDB_TABLE_FNAME_LEN] = {0};




×








UNCOV

342



  (void)tNameGetFullDbName(&name, db);




×







343













UNCOV

344



  return mndAcquireDb(pMnode, db);




×







345



}










346













UNCOV

347



int32_t mndSetCreateIdxPrepareLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

348



  int32_t  code = 0;




×








UNCOV

349



  SSdbRaw *pRedoRaw = mndIdxActionEncode(pIdx);




×








UNCOV

350



  if (pRedoRaw == NULL) {





×







351



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







352



    if (terrno != 0) code = terrno;





×







353



    return -1;




×







354



  }











UNCOV

355



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));





×








UNCOV

356



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING));





×







357













UNCOV

358



  TAOS_RETURN(code);




×







359



}










360













UNCOV

361



int32_t mndSetCreateIdxCommitLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

362



  int32_t  code = 0;




×








UNCOV

363



  SSdbRaw *pCommitRaw = mndIdxActionEncode(pIdx);




×








UNCOV

364



  if (pCommitRaw == NULL) {





×







365



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







366



    if (terrno != 0) code = terrno;





×







367



    return -1;




×







368



  }











UNCOV

369



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

370



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×







371













UNCOV

372



  TAOS_RETURN(code);




×







373



}










374













UNCOV

375



int32_t mndSetAlterIdxPrepareLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

376



  int32_t  code = 0;




×








UNCOV

377



  SSdbRaw *pRedoRaw = mndIdxActionEncode(pIdx);




×








UNCOV

378



  if (pRedoRaw == NULL) {





×







379



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







380



    if (terrno != 0) code = terrno;





×







381



    return -1;




×







382



  }











UNCOV

383



  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {





×







384



    sdbFreeRaw(pRedoRaw);




×







385



    return -1;




×







386



  }











UNCOV

387



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY));





×







388













UNCOV

389



  TAOS_RETURN(code);




×







390



}










391













UNCOV

392



int32_t mndSetAlterIdxCommitLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

393



  int32_t  code = 0;




×








UNCOV

394



  SSdbRaw *pCommitRaw = mndIdxActionEncode(pIdx);




×








UNCOV

395



  if (pCommitRaw == NULL) {





×







396



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







397



    if (terrno != 0) code = terrno;





×







398



    TAOS_RETURN(code);




×







399



  }











UNCOV

400



  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {





×







401



    sdbFreeRaw(pCommitRaw);




×







402



    TAOS_RETURN(code);




×







403



  }











UNCOV

404



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×







405













UNCOV

406



  TAOS_RETURN(code);




×







407



}










408












409



static int32_t mndSetCreateIdxVgroupRedoLogs(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup) {




×







410



  int32_t  code = 0;




×







411



  SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




×







412



  if (pVgRaw == NULL) {





×







413



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







414



    if (terrno != 0) code = terrno;





×







415



    TAOS_RETURN(code);




×







416



  }










417



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));





×







418



  TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_CREATING));





×







419



  TAOS_RETURN(code);




×







420



}










421












422



static int32_t mndSetCreateIdxVgroupCommitLogs(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup) {




×







423



  int32_t  code = 0;




×







424



  SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




×







425



  if (pVgRaw == NULL) {





×







426



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







427



    if (terrno != 0) code = terrno;





×







428



    TAOS_RETURN(code);




×







429



  }










430



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));





×







431



  TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));





×







432



  TAOS_RETURN(code);




×







433



}










434












435



// static int32_t mndSetUpdateIdxStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStbObj *pStb) {










436



//   SStbObj stbObj = {0};










437



//   taosRLockLatch(&pStb->lock);










438



//   memcpy(&stbObj, pStb, sizeof(SStbObj));










439



//   taosRUnLockLatch(&pStb->lock);










440



//   stbObj.numOfColumns = 0;










441



//   stbObj.pColumns = NULL;










442



//   stbObj.numOfTags = 0;










443



//  stbObj.pTags = NULL;










444



//   stbObj.numOfFuncs = 0;










445



//   stbObj.pFuncs = NULL;










446



//   stbObj.updateTime = taosGetTimestampMs();










447



//   stbObj.lock = 0;










448



//   stbObj.tagVer++;










449












450



// SSdbRaw *pCommitRaw = mndStbActionEncode(&stbObj);










451



// if (pCommitRaw == NULL) return -1;










452



// if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;










453



// if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;










454



//










455



// return 0;










456



//}










457












458



static void mndDestroyIdxObj(SIdxObj *pIdxObj) {




×







459



  if (pIdxObj) {










460



    // do nothing










461



  }










462



}




×







463













UNCOV

464



static int32_t mndProcessCreateIdxReq(SRpcMsg *pReq) {




×








UNCOV

465



  SMnode  *pMnode = pReq->info.node;




×








UNCOV

466



  int32_t  code = -1;




×








UNCOV

467



  SStbObj *pStb = NULL;




×








UNCOV

468



  SIdxObj *pIdx = NULL;




×







469













UNCOV

470



  SDbObj            *pDb = NULL;




×








UNCOV

471



  SCreateTagIndexReq createReq = {0};




×







472













UNCOV

473



  TAOS_CHECK_GOTO(tDeserializeSCreateTagIdxReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);





×







474













UNCOV

475



  mInfo("idx:%s start to create", createReq.idxName);





×







476



  // if (mndCheckCreateIdxReq(&createReq) != 0) {










477



  //   goto _OVER;










478



  // }










479













UNCOV

480



  pDb = mndAcquireDbByStb(pMnode, createReq.stbName);




×








UNCOV

481



  if (pDb == NULL) {





×







482



    code = TSDB_CODE_MND_DB_NOT_EXIST;




×







483



    if (terrno != 0) code = terrno;





×







484



    goto _OVER;




×







485



  }










486













UNCOV

487



  pStb = mndAcquireStb(pMnode, createReq.stbName);




×








UNCOV

488



  if (pStb == NULL) {





×







489



    mError("idx:%s, failed to create since stb:%s not exist", createReq.idxName, createReq.stbName);





×







490



    code = TSDB_CODE_MND_DB_NOT_EXIST;




×







491



    if (terrno != 0) code = terrno;





×







492



    goto _OVER;




×







493



  }











UNCOV

494



  SSIdx idx = {0};




×








UNCOV

495



  if ((code = mndAcquireGlobalIdx(pMnode, createReq.idxName, SDB_IDX, &idx)) == 0) {





×








UNCOV

496



    pIdx = idx.pIdx;




×







497



  } else {











UNCOV

498



    goto _OVER;




×







499



  }











UNCOV

500



  if (pIdx != NULL) {





×








UNCOV

501



    code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;




×








UNCOV

502



    goto _OVER;




×







503



  }










504













UNCOV

505



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb), NULL, _OVER);





×







506













UNCOV

507



  code = mndAddIndex(pMnode, pReq, &createReq, pDb, pStb);




×








UNCOV

508



  if (terrno == TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST || terrno == TSDB_CODE_MND_TAG_NOT_EXIST) {





×








UNCOV

509



    return terrno;




×







510



  } else {











UNCOV

511



    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







512



  }










513












514



_OVER:




×








UNCOV

515



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





×








UNCOV

516



    mError("stb:%s, failed to create since %s", createReq.idxName, tstrerror(code));





×







517



  }










518













UNCOV

519



  mndReleaseStb(pMnode, pStb);




×








UNCOV

520



  mndReleaseIdx(pMnode, pIdx);




×








UNCOV

521



  mndReleaseDb(pMnode, pDb);




×







522













UNCOV

523



  TAOS_RETURN(code);




×







524



}










525













UNCOV

526



int32_t mndSetDropIdxPrepareLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

527



  int32_t  code = 0;




×








UNCOV

528



  SSdbRaw *pRedoRaw = mndIdxActionEncode(pIdx);




×








UNCOV

529



  if (pRedoRaw == NULL) {





×







530



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







531



    if (terrno != 0) code = terrno;





×







532



    TAOS_RETURN(code);




×







533



  }











UNCOV

534



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));





×








UNCOV

535



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));





×







536













UNCOV

537



  TAOS_RETURN(code);




×







538



}










539













UNCOV

540



int32_t mndSetDropIdxCommitLogs(SMnode *pMnode, STrans *pTrans, SIdxObj *pIdx) {




×








UNCOV

541



  int32_t  code = 0;




×








UNCOV

542



  SSdbRaw *pCommitRaw = mndIdxActionEncode(pIdx);




×








UNCOV

543



  if (pCommitRaw == NULL) {





×







544



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







545



    if (terrno != 0) code = terrno;





×







546



    TAOS_RETURN(code);




×







547



  }











UNCOV

548



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

549



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));





×







550













UNCOV

551



  TAOS_RETURN(code);




×







552



}










553












554



static int32_t mndProcessGetTbIdxReq(SRpcMsg *pReq) {




×







555



  //










556



  return 0;




×







557



}










558













UNCOV

559



int32_t mndRetrieveTagIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {




×








UNCOV

560



  SMnode  *pMnode = pReq->info.node;




×








UNCOV

561



  SSdb    *pSdb = pMnode->pSdb;




×








UNCOV

562



  int32_t  numOfRows = 0;




×








UNCOV

563



  SIdxObj *pIdx = NULL;




×








UNCOV

564



  int32_t  cols = 0;




×








UNCOV

565



  int32_t  code = 0;




×








UNCOV

566



  int32_t  lino = 0;




×







567













UNCOV

568



  SDbObj *pDb = NULL;




×








UNCOV

569



  if (strlen(pShow->db) > 0) {





×








UNCOV

570



    pDb = mndAcquireDb(pMnode, pShow->db);




×








UNCOV

571



    if (pDb == NULL) return 0;





×







572



  }











UNCOV

573



  SSmaAndTagIter *pIter = pShow->pIter;




×








UNCOV

574



  while (numOfRows < rows) {





×








UNCOV

575



    pIter->pIdxIter = sdbFetch(pSdb, SDB_IDX, pIter->pIdxIter, (void **)&pIdx);




×








UNCOV

576



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





×







577













UNCOV

578



    if (NULL != pDb && pIdx->dbUid != pDb->uid) {





×








UNCOV

579



      sdbRelease(pSdb, pIdx);




×








UNCOV

580



      continue;




×







581



    }










582













UNCOV

583



    cols = 0;




×







584













UNCOV

585



    SName idxName = {0};




×








UNCOV

586



    if ((code = tNameFromString(&idxName, pIdx->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) {





×







587



      sdbRelease(pSdb, pIdx);




×







588



      goto _OVER;




×







589



    }











UNCOV

590



    char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×







591













UNCOV

592



    STR_TO_VARSTR(n1, (char *)tNameGetTableName(&idxName));




×







593













UNCOV

594



    char n2[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

595



    STR_TO_VARSTR(n2, (char *)mndGetDbStr(pIdx->db));




×







596













UNCOV

597



    SName stbName = {0};




×








UNCOV

598



    if ((code = tNameFromString(&stbName, pIdx->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) {





×







599



      sdbRelease(pSdb, pIdx);




×







600



      goto _OVER;




×







601



    }











UNCOV

602



    char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

603



    STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName));




×







604













UNCOV

605



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




×








UNCOV

606



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)n1, false), pIdx, &lino, _OVER);





×







607













UNCOV

608



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




×








UNCOV

609



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)n2, false), pIdx, &lino, _OVER);





×







610













UNCOV

611



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




×








UNCOV

612



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)n3, false), pIdx, &lino, _OVER);





×







613













UNCOV

614



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




×







615













UNCOV

616



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, NULL, true), pIdx, &lino, _OVER);





×







617













UNCOV

618



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




×








UNCOV

619



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)&pIdx->createdTime, false), pIdx, &lino,





×







620



                        _OVER);










621













UNCOV

622



    char col[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

623



    STR_TO_VARSTR(col, (char *)pIdx->colName);




×







624













UNCOV

625



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




×








UNCOV

626



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)col, false), pIdx, &lino, _OVER);





×







627













UNCOV

628



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




×







629













UNCOV

630



    char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

631



    STR_TO_VARSTR(tag, (char *)"tag_index");




×








UNCOV

632



    RETRIEVE_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, (const char *)tag, false), pIdx, &lino, _OVER);





×







633













UNCOV

634



    numOfRows++;




×








UNCOV

635



    sdbRelease(pSdb, pIdx);




×







636



  }










637













UNCOV

638



_OVER:




×








UNCOV

639



  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));





×







640













UNCOV

641



  mndReleaseDb(pMnode, pDb);




×








UNCOV

642



  pShow->numOfRows += numOfRows;




×








UNCOV

643



  return numOfRows;




×







644



}










645












646



// static void mndCancelGetNextIdx(SMnode *pMnode, void *pIter) {










647



//   SSdb *pSdb = pMnode->pSdb;










648



//










649



//  sdbCancelFetch(pSdb, pIter);










650



//}










651



static int32_t mndCheckIndexReq(SCreateTagIndexReq *pReq) {




×







652



  // impl










653



  return TSDB_CODE_SUCCESS;




×







654



}










655













UNCOV

656



static int32_t mndSetUpdateIdxStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStbObj *pOld, SStbObj *pNew, char *tagName,




×







657



                                            int on) {











UNCOV

658



  int32_t code = 0;




×








UNCOV

659



  taosRLockLatch(&pOld->lock);




×








UNCOV

660



  memcpy(pNew, pOld, sizeof(SStbObj));




×








UNCOV

661



  taosRUnLockLatch(&pOld->lock);




×







662













UNCOV

663



  pNew->pTags = NULL;




×








UNCOV

664



  pNew->pColumns = NULL;




×








UNCOV

665



  pNew->pCmpr = NULL;




×








UNCOV

666



  pNew->pTags = NULL;




×








UNCOV

667



  pNew->updateTime = taosGetTimestampMs();




×








UNCOV

668



  pNew->lock = 0;




×







669













UNCOV

670



  int8_t  hasIdx = 0;




×








UNCOV

671



  int32_t tag = mndFindSuperTableTagId(pOld, tagName, &hasIdx);




×








UNCOV

672



  if (tag < 0) {





×







673



    code = TSDB_CODE_MND_TAG_NOT_EXIST;




×







674



    TAOS_RETURN(code);




×







675



  }











UNCOV

676



  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));





×








UNCOV

677



  SSchema *pTag = pNew->pTags + tag;




×







678













UNCOV

679



  if (on == 1) {





×








UNCOV

680



    if (hasIdx && tag != 0) {





×







681



      code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;




×







682



      TAOS_RETURN(code);




×







683



    } else {











UNCOV

684



      SSCHMEA_SET_IDX_ON(pTag);




×







685



    }










686



  } else {











UNCOV

687



    if (hasIdx == 0) {





×







688



      code = TSDB_CODE_MND_SMA_NOT_EXIST;




×







689



    } else {











UNCOV

690



      SSCHMEA_SET_IDX_OFF(pTag);




×








UNCOV

691



      pTag->flags = 0;




×







692



    }










693



  }











UNCOV

694



  pNew->tagVer++;




×







695













UNCOV

696



  SSdbRaw *pCommitRaw = mndStbActionEncode(pNew);




×








UNCOV

697



  if (pCommitRaw == NULL) {





×







698



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







699



    if (terrno != 0) code = terrno;





×







700



    TAOS_RETURN(code);




×







701



  }











UNCOV

702



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

703



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×







704













UNCOV

705



  TAOS_RETURN(code);




×







706



}











UNCOV

707



int32_t mndAddIndexImpl(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, SIdxObj *pIdx) {




×







708



  // impl later











UNCOV

709



  int32_t code = -1;




×








UNCOV

710



  SStbObj newStb = {0};




×








UNCOV

711



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq, "create-stb-index");




×








UNCOV

712



  if (pTrans == NULL) goto _OVER;





×







713












714



  // mInfo("trans:%d, used to add index to stb:%s", pTrans->id, pStb->name);











UNCOV

715



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




×








UNCOV

716



  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);





×







717













UNCOV

718



  mndTransSetSerial(pTrans);




×







719













UNCOV

720



  TAOS_CHECK_GOTO(mndSetCreateIdxPrepareLogs(pMnode, pTrans, pIdx), NULL, _OVER);





×








UNCOV

721



  TAOS_CHECK_GOTO(mndSetCreateIdxCommitLogs(pMnode, pTrans, pIdx), NULL, _OVER);





×







722













UNCOV

723



  TAOS_CHECK_GOTO(mndSetUpdateIdxStbCommitLogs(pMnode, pTrans, pStb, &newStb, pIdx->colName, 1), NULL, _OVER);





×








UNCOV

724



  TAOS_CHECK_GOTO(mndSetCreateIdxRedoActions(pMnode, pTrans, pDb, &newStb, pIdx), NULL, _OVER);





×







725













UNCOV

726



  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);





×







727













UNCOV

728



  code = 0;




×







729













UNCOV

730



_OVER:




×







731



  // mndDestoryIdxObj(pIdx);











UNCOV

732



  if (newStb.pTags != NULL) {





×








UNCOV

733



    taosMemoryFree(newStb.pTags);





×








UNCOV

734



    taosMemoryFree(newStb.pColumns);





×








UNCOV

735



    taosMemoryFree(newStb.pCmpr);





×







736



  }











UNCOV

737



  mndTransDrop(pTrans);




×








UNCOV

738



  TAOS_RETURN(code);




×







739



}











UNCOV

740



int8_t mndCheckIndexNameByTagName(SMnode *pMnode, SIdxObj *pIdxObj) {




×







741



  // build index on first tag, and no index name;











UNCOV

742



  int8_t  exist = 0;




×








UNCOV

743



  SDbObj *pDb = NULL;




×








UNCOV

744



  if (strlen(pIdxObj->db) > 0) {





×








UNCOV

745



    pDb = mndAcquireDb(pMnode, pIdxObj->db);




×








UNCOV

746



    if (pDb == NULL) return 0;





×







747



  }











UNCOV

748



  SSmaAndTagIter *pIter = NULL;




×








UNCOV

749



  SIdxObj        *pIdx = NULL;




×








UNCOV

750



  SSdb           *pSdb = pMnode->pSdb;




×







751












752



  while (1) {











UNCOV

753



    pIter = sdbFetch(pSdb, SDB_IDX, pIter, (void **)&pIdx);




×








UNCOV

754



    if (pIter == NULL) break;





×







755













UNCOV

756



    if (NULL != pDb && pIdx->dbUid != pDb->uid) {





×







757



      sdbRelease(pSdb, pIdx);




×







758



      continue;




×







759



    }











UNCOV

760



    if (pIdxObj->stbUid != pIdx->stbUid) {





×







761



      sdbRelease(pSdb, pIdx);




×







762



      continue;




×







763



    }











UNCOV

764



    if (strncmp(pIdxObj->colName, pIdx->colName, TSDB_COL_NAME_LEN) == 0) {





×








UNCOV

765



      sdbCancelFetch(pSdb, pIter);




×








UNCOV

766



      sdbRelease(pSdb, pIdx);




×








UNCOV

767



      exist = 1;




×








UNCOV

768



      break;




×







769



    }










770



    sdbRelease(pSdb, pIdx);




×







771



  }










772













UNCOV

773



  mndReleaseDb(pMnode, pDb);




×








UNCOV

774



  return exist;




×







775



}











UNCOV

776



static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *req, SDbObj *pDb, SStbObj *pStb) {




×








UNCOV

777



  int32_t code = -1;




×








UNCOV

778



  SIdxObj idxObj = {0};




×








UNCOV

779



  memcpy(idxObj.name, req->idxName, TSDB_INDEX_FNAME_LEN);




×








UNCOV

780



  memcpy(idxObj.stb, pStb->name, TSDB_TABLE_FNAME_LEN);




×








UNCOV

781



  memcpy(idxObj.db, pDb->name, TSDB_DB_FNAME_LEN);




×








UNCOV

782



  memcpy(idxObj.colName, req->colName, TSDB_COL_NAME_LEN);




×







783













UNCOV

784



  idxObj.createdTime = taosGetTimestampMs();




×








UNCOV

785



  idxObj.uid = mndGenerateUid(req->idxName, strlen(req->idxName));




×








UNCOV

786



  idxObj.stbUid = pStb->uid;




×








UNCOV

787



  idxObj.dbUid = pStb->dbUid;




×







788













UNCOV

789



  int8_t  hasIdx = 0;




×








UNCOV

790



  int32_t tag = mndFindSuperTableTagId(pStb, req->colName, &hasIdx);




×








UNCOV

791



  if (tag < 0) {





×







792



    code = TSDB_CODE_MND_TAG_NOT_EXIST;




×







793



    TAOS_RETURN(code);




×







794



  }











UNCOV

795



  int8_t exist = 0;




×








UNCOV

796



  if (tag == 0 && hasIdx == 1) {





×








UNCOV

797



    exist = mndCheckIndexNameByTagName(pMnode, &idxObj);




×








UNCOV

798



    if (exist) {





×








UNCOV

799



      code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;




×








UNCOV

800



      TAOS_RETURN(code);




×







801



    }











UNCOV

802



  } else if (hasIdx == 1) {





×








UNCOV

803



    code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;




×








UNCOV

804



    TAOS_RETURN(code);




×







805



  }










806













UNCOV

807



  code = mndAddIndexImpl(pMnode, pReq, pDb, pStb, &idxObj);




×








UNCOV

808



  TAOS_RETURN(code);




×







809



}










810













UNCOV

811



static int32_t mndDropIdx(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SIdxObj *pIdx) {




×








UNCOV

812



  int32_t  code = -1;




×








UNCOV

813



  SStbObj *pStb = NULL;




×








UNCOV

814



  STrans  *pTrans = NULL;




×







815













UNCOV

816



  SStbObj newObj = {0};




×







817













UNCOV

818



  pStb = mndAcquireStb(pMnode, pIdx->stb);




×








UNCOV

819



  if (pStb == NULL) {





×







820



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







821



    if (terrno != 0) code = terrno;





×







822



    goto _OVER;




×







823



  }










824













UNCOV

825



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




×








UNCOV

826



  if (pTrans == NULL) {





×







827



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







828



    if (terrno != 0) code = terrno;





×







829



    goto _OVER;




×







830



  }










831













UNCOV

832



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





×








UNCOV

833



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




×








UNCOV

834



  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);





×







835













UNCOV

836



  mndTransSetSerial(pTrans);




×








UNCOV

837



  TAOS_CHECK_GOTO(mndSetDropIdxPrepareLogs(pMnode, pTrans, pIdx), NULL, _OVER);





×








UNCOV

838



  TAOS_CHECK_GOTO(mndSetDropIdxCommitLogs(pMnode, pTrans, pIdx), NULL, _OVER);





×







839













UNCOV

840



  TAOS_CHECK_GOTO(mndSetUpdateIdxStbCommitLogs(pMnode, pTrans, pStb, &newObj, pIdx->colName, 0), NULL, _OVER);





×








UNCOV

841



  TAOS_CHECK_GOTO(mndSetDropIdxRedoActions(pMnode, pTrans, pDb, &newObj, pIdx), NULL, _OVER);





×








UNCOV

842



  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);





×







843













UNCOV

844



  code = 0;




×







845













UNCOV

846



_OVER:




×








UNCOV

847



  taosMemoryFree(newObj.pTags);





×








UNCOV

848



  taosMemoryFree(newObj.pColumns);





×








UNCOV

849



  taosMemoryFree(newObj.pCmpr);





×







850













UNCOV

851



  mndTransDrop(pTrans);




×








UNCOV

852



  mndReleaseStb(pMnode, pStb);




×








UNCOV

853



  TAOS_RETURN(code);




×







854



}











UNCOV

855



int32_t mndProcessDropTagIdxReq(SRpcMsg *pReq) {




×








UNCOV

856



  SMnode  *pMnode = pReq->info.node;




×








UNCOV

857



  int32_t  code = -1;




×








UNCOV

858



  SDbObj  *pDb = NULL;




×








UNCOV

859



  SIdxObj *pIdx = NULL;




×







860













UNCOV

861



  SDropTagIndexReq req = {0};




×








UNCOV

862



  TAOS_CHECK_GOTO(tDeserializeSDropTagIdxReq(pReq->pCont, pReq->contLen, &req), NULL, _OVER);





×








UNCOV

863



  mInfo("idx:%s, start to drop", req.name);





×








UNCOV

864



  SSIdx idx = {0};




×








UNCOV

865



  if ((code = mndAcquireGlobalIdx(pMnode, req.name, SDB_IDX, &idx)) == 0) {





×








UNCOV

866



    pIdx = idx.pIdx;




×







867



  } else {










868



    goto _OVER;




×







869



  }











UNCOV

870



  if (pIdx == NULL) {





×







871



    if (req.igNotExists) {





×







872



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





×







873



      code = 0;




×







874



      goto _OVER;




×







875



    } else {










876



      code = TSDB_CODE_MND_TAG_INDEX_NOT_EXIST;




×







877



      goto _OVER;




×







878



    }










879



  }










880













UNCOV

881



  pDb = mndAcquireDbByIdx(pMnode, req.name);




×








UNCOV

882



  if (pDb == NULL) {





×







883



    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;




×







884



    if (terrno != 0) code = terrno;





×







885



    goto _OVER;




×







886



  }










887













UNCOV

888



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb), NULL, _OVER);





×







889













UNCOV

890



  code = mndDropIdx(pMnode, pReq, pDb, pIdx);




×








UNCOV

891



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







892












893



_OVER:




×








UNCOV

894



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





×







895



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





×







896



  }











UNCOV

897



  mndReleaseIdx(pMnode, pIdx);




×








UNCOV

898



  mndReleaseDb(pMnode, pDb);




×








UNCOV

899



  TAOS_RETURN(code);




×







900



}










901



static int32_t mndProcessGetIdxReq(SRpcMsg *pReq) {




×







902



  // do nothing










903



  return 0;




×







904



}










905













UNCOV

906



int32_t mndDropIdxsByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {




×








UNCOV

907



  int32_t code = 0;




×








UNCOV

908



  SSdb   *pSdb = pMnode->pSdb;




×








UNCOV

909



  void   *pIter = NULL;




×







910













UNCOV

911



  while (1) {




×








UNCOV

912



    SIdxObj *pIdx = NULL;




×








UNCOV

913



    pIter = sdbFetch(pSdb, SDB_IDX, pIter, (void **)&pIdx);




×








UNCOV

914



    if (pIter == NULL) break;





×







915













UNCOV

916



    if (pIdx->stbUid == pStb->uid) {





×








UNCOV

917



      if ((code = mndSetDropIdxCommitLogs(pMnode, pTrans, pIdx)) != 0) {





×







918



        sdbCancelFetch(pSdb, pIter);




×







919



        sdbRelease(pSdb, pIdx);




×







920



        TAOS_RETURN(code);




×







921



      }










922



    }










923













UNCOV

924



    sdbRelease(pSdb, pIdx);




×







925



  }










926













UNCOV

927



  TAOS_RETURN(code);




×







928



}










929













UNCOV

930



int32_t mndGetIdxsByTagName(SMnode *pMnode, SStbObj *pStb, char *tagName, SIdxObj *idx) {




×








UNCOV

931



  SSdb *pSdb = pMnode->pSdb;




×








UNCOV

932



  void *pIter = NULL;




×







933













UNCOV

934



  while (1) {




×








UNCOV

935



    SIdxObj *pIdx = NULL;




×








UNCOV

936



    pIter = sdbFetch(pSdb, SDB_IDX, pIter, (void **)&pIdx);




×








UNCOV

937



    if (pIter == NULL) break;





×







938













UNCOV

939



    if (pIdx->stbUid == pStb->uid && strcasecmp(pIdx->colName, tagName) == 0) {





×








UNCOV

940



      memcpy((char *)idx, (char *)pIdx, sizeof(SIdxObj));




×








UNCOV

941



      sdbRelease(pSdb, pIdx);




×








UNCOV

942



      sdbCancelFetch(pSdb, pIter);




×








UNCOV

943



      return 0;




×







944



    }










945













UNCOV

946



    sdbRelease(pSdb, pIdx);




×







947



  }










948













UNCOV

949



  return -1;




×







950



}











UNCOV

951



int32_t mndDropIdxsByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {




×








UNCOV

952



  int32_t code = 0;




×








UNCOV

953



  SSdb   *pSdb = pMnode->pSdb;




×








UNCOV

954



  void   *pIter = NULL;




×







955













UNCOV

956



  while (1) {




×








UNCOV

957



    SIdxObj *pIdx = NULL;




×








UNCOV

958



    pIter = sdbFetch(pSdb, SDB_IDX, pIter, (void **)&pIdx);




×








UNCOV

959



    if (pIter == NULL) break;





×







960













UNCOV

961



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





×








UNCOV

962



      if ((code = mndSetDropIdxCommitLogs(pMnode, pTrans, pIdx)) != 0) {





×







963



        sdbRelease(pSdb, pIdx);




×







964



        sdbCancelFetch(pSdb, pIter);




×







965



        TAOS_RETURN(code);




×







966



      }










967



    }










968













UNCOV

969



    sdbRelease(pSdb, pIdx);




×







970



  }










971













UNCOV

972



  TAOS_RETURN(code);




×







973



}
























    

  • 

    •