taosdata / TDengine / #4997

coverage: 71.739% (-0.3%) from 72.069%
#4997

push

travis-ci

web-flow 
feat: add query phase tracking for SHOW QUERIES (#34706)

148 of 183 new or added lines in 10 files covered. (80.87%)

9273 existing lines in 172 files now uncovered.

244572 of 340921 relevant lines covered (71.74%)

133392941.95 hits per line

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

81.3
/source/dnode/mnode/impl/src/mndDb.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 "mndDb.h"










18



#include "audit.h"










19



#include "command.h"










20



#include "mndArbGroup.h"










21



#include "mndCluster.h"










22



#include "mndCompact.h"










23



#include "mndCompactDetail.h"










24



#include "mndConfig.h"










25



#include "mndDnode.h"










26



#include "mndEncryptAlgr.h"










27



#include "mndIndex.h"










28



#include "mndPrivilege.h"










29



#include "mndRetention.h"










30



#include "mndRetentionDetail.h"










31



#include "mndRsma.h"










32



#include "mndScan.h"










33



#include "mndShow.h"










34



#include "mndSma.h"










35



#include "mndSsMigrate.h"










36



#include "mndStb.h"










37



#include "mndStream.h"










38



#include "mndSubscribe.h"










39



#include "mndTopic.h"










40



#include "mndTrans.h"










41



#include "mndUser.h"










42



#include "mndVgroup.h"










43



#include "mndView.h"










44



#include "systable.h"










45



#include "thttp.h"










46



#include "tjson.h"










47












48



#define DB_VER_INITIAL                   1










49



#define DB_VER_SUPPORT_ADVANCED_SECURITY 2










50



#define DB_VER_NUMBER                    DB_VER_SUPPORT_ADVANCED_SECURITY










51












52



#define DB_RESERVE_SIZE 8










53












54



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);










55



static int32_t  mndDbActionInsert(SSdb *pSdb, SDbObj *pDb);










56



static int32_t  mndDbActionDelete(SSdb *pSdb, SDbObj *pDb);










57



static int32_t  mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew);










58



static int32_t  mndNewDbActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *pRaw);










59












60



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq);










61



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq);










62



static int32_t mndProcessDropDbReq(SRpcMsg *pReq);










63



static int32_t mndProcessUseDbReq(SRpcMsg *pReq);










64



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq);










65



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq);










66



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq);










67



static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq);










68



static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);










69



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










70



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq);










71












72



#ifndef TD_ENTERPRISE










73



int32_t mndProcessCompactDbReq(SRpcMsg *pReq) { return TSDB_CODE_OPS_NOT_SUPPORT; }










74



#endif










75












76



int32_t mndInitDb(SMnode *pMnode) {




443,612✔





77



  SSdbTable table = {




443,612✔





78



      .sdbType = SDB_DB,










79



      .keyType = SDB_KEY_BINARY,










80



      .encodeFp = (SdbEncodeFp)mndDbActionEncode,










81



      .decodeFp = (SdbDecodeFp)mndDbActionDecode,










82



      .insertFp = (SdbInsertFp)mndDbActionInsert,










83



      .updateFp = (SdbUpdateFp)mndDbActionUpdate,










84



      .deleteFp = (SdbDeleteFp)mndDbActionDelete,










85



      .validateFp = (SdbValidateFp)mndNewDbActionValidate,










86



  };










87












88



  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbReq);




443,612✔





89



  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);




443,612✔





90



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);




443,612✔





91



  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);




443,612✔





92



  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);




443,612✔





93



  mndSetMsgHandle(pMnode, TDMT_MND_SCAN_DB, mndProcessScanDbReq);




443,612✔





94



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);




443,612✔





95



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB_WAL, mndProcessTrimDbWalReq);




443,612✔





96



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);




443,612✔





97



  mndSetMsgHandle(pMnode, TDMT_MND_SSMIGRATE_DB, mndProcessSsMigrateDbReq);




443,612✔





98



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);




443,612✔





99












100



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);




443,612✔





101



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);




443,612✔





102












103



  return sdbSetTable(pMnode->pSdb, table);




443,612✔





104



}










105












106



void mndCleanupDb(SMnode *pMnode) {}




443,548✔





107












108



SSdbRaw *mndDbActionEncode(SDbObj *pDb) {




6,148,463✔





109



  int32_t code = 0;




6,148,463✔





110



  int32_t lino = 0;




6,148,463✔





111



  terrno = TSDB_CODE_OUT_OF_MEMORY;




6,148,463✔





112












113



  int32_t  size = sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + DB_RESERVE_SIZE;




6,148,463✔





114



  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, DB_VER_NUMBER, size);




6,148,463✔





115



  if (pRaw == NULL) goto _OVER;




6,148,463✔





116












117



  int32_t dataPos = 0;




6,148,463✔





118



  SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)




6,148,463✔





119



  SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)




6,148,463✔





120



  SDB_SET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)




6,148,463✔





121



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




6,148,463✔





122



  SDB_SET_INT64(pRaw, dataPos, pDb->updateTime, _OVER)




6,148,463✔





123



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




6,148,463✔





124



  SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, _OVER)




6,148,463✔





125



  SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, _OVER)




6,148,463✔





126



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, _OVER)




6,148,463✔





127



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfStables, _OVER)




6,148,463✔





128



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.buffer, _OVER)




6,148,463✔





129



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pageSize, _OVER)




6,148,463✔





130



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pages, _OVER)




6,148,463✔





131



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheLastSize, _OVER)




6,148,463✔





132



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, _OVER)




6,148,463✔





133



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, _OVER)




6,148,463✔





134



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, _OVER)




6,148,463✔





135



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, _OVER)




6,148,463✔





136



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, _OVER)




6,148,463✔





137



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, _OVER)




6,148,463✔





138



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walFsyncPeriod, _OVER)




6,148,463✔





139



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, _OVER)




6,148,463✔





140



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, _OVER)




6,148,463✔





141



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, _OVER)




6,148,463✔





142



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, _OVER)




6,148,463✔





143



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.strict, _OVER)




6,148,463✔





144



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLast, _OVER)




6,148,463✔





145



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.hashMethod, _OVER)




6,148,463✔





146



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, _OVER)




6,148,463✔





147



  for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {




6,148,463✔





148



    SRetention *pRetension = taosArrayGet(pDb->cfg.pRetensions, i);




×







149



    SDB_SET_INT64(pRaw, dataPos, pRetension->freq, _OVER)




×







150



    SDB_SET_INT64(pRaw, dataPos, pRetension->keep, _OVER)




×







151



    SDB_SET_INT8(pRaw, dataPos, pRetension->freqUnit, _OVER)




×







152



    SDB_SET_INT8(pRaw, dataPos, pRetension->keepUnit, _OVER)




×







153



  }










154



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.schemaless, _OVER)




6,148,463✔





155



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRetentionPeriod, _OVER)




6,148,463✔





156



  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walRetentionSize, _OVER)




6,148,463✔





157



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRollPeriod, _OVER)




6,148,463✔





158



  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walSegmentSize, _OVER)




6,148,463✔





159



  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.sstTrigger, _OVER)




6,148,463✔





160



  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER)




6,148,463✔





161



  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER)




6,148,463✔





162



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER)




6,148,463✔





163



  SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER)




6,148,463✔





164



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.keepTimeOffset, _OVER)




6,148,463✔





165



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.ssChunkSize, _OVER)




6,148,463✔





166



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.ssKeepLocal, _OVER)




6,148,463✔





167



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.ssCompact, _OVER)




6,148,463✔





168



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.withArbitrator, _OVER)




6,148,463✔





169



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.encryptAlgorithm, _OVER)




6,148,463✔





170



  SDB_SET_INT32(pRaw, dataPos, pDb->tsmaVersion, _OVER);




6,148,463✔





171



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compactTimeOffset, _OVER)




6,148,463✔





172



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactStartTime, _OVER)




6,148,463✔





173



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactEndTime, _OVER)




6,148,463✔





174



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactInterval, _OVER)




6,148,463✔





175



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.isAudit, _OVER)




6,148,463✔





176



  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.secureDelete, _OVER)




6,148,463✔





177



  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheLastShardBits, _OVER)




6,148,463✔





178












179



  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




6,148,463✔





180



  SDB_SET_UINT8(pRaw, dataPos, pDb->cfg.flags, _OVER)




6,148,463✔





181



  SDB_SET_INT64(pRaw, dataPos, pDb->ownerId, _OVER)




6,148,463✔





182












183



  SDB_SET_DATALEN(pRaw, dataPos, _OVER)




6,148,463✔





184












185



  terrno = 0;




6,148,463✔





186












187



_OVER:




6,148,463✔





188



  if (terrno != 0) {




6,148,463✔





189



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




×







190



    sdbFreeRaw(pRaw);




×








UNCOV

191



    return NULL;




×







192



  }










193












194



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




6,148,463✔





195



  return pRaw;




6,148,463✔





196



}










197












198



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {




5,550,194✔





199



  int32_t code = 0;




5,550,194✔





200



  int32_t lino = 0;




5,550,194✔





201



  terrno = TSDB_CODE_OUT_OF_MEMORY;




5,550,194✔





202



  SSdbRow *pRow = NULL;




5,550,194✔





203



  SDbObj  *pDb = NULL;




5,550,194✔





204












205



  int8_t sver = 0;




5,550,194✔





206



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




5,550,194✔





207












208



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




5,550,194✔





209



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×








UNCOV

210



    goto _OVER;




×







211



  }










212












213



  pRow = sdbAllocRow(sizeof(SDbObj));




5,550,194✔





214



  if (pRow == NULL) goto _OVER;




5,550,194✔





215












216



  pDb = sdbGetRowObj(pRow);




5,550,194✔





217



  if (pDb == NULL) goto _OVER;




5,550,194✔





218












219



  int32_t dataPos = 0;




5,550,194✔





220



  SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)




5,550,194✔





221



  SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)




5,550,194✔





222



  SDB_GET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)




5,550,194✔





223



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




5,550,194✔





224



  SDB_GET_INT64(pRaw, dataPos, &pDb->updateTime, _OVER)




5,550,194✔





225



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




5,550,194✔





226



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, _OVER)




5,550,194✔





227



  SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, _OVER)




5,550,194✔





228



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, _OVER)




5,550,194✔





229



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfStables, _OVER)




5,550,194✔





230



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.buffer, _OVER)




5,550,194✔





231



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pageSize, _OVER)




5,550,194✔





232



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pages, _OVER)




5,550,194✔





233



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheLastSize, _OVER)




5,550,194✔





234



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, _OVER)




5,550,194✔





235



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, _OVER)




5,550,194✔





236



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, _OVER)




5,550,194✔





237



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, _OVER)




5,550,194✔





238



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, _OVER)




5,550,194✔





239



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, _OVER)




5,550,194✔





240



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walFsyncPeriod, _OVER)




5,550,194✔





241



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, _OVER)




5,550,194✔





242



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, _OVER)




5,550,194✔





243



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, _OVER)




5,550,194✔





244



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, _OVER)




5,550,194✔





245



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.strict, _OVER)




5,550,194✔





246



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLast, _OVER)




5,550,194✔





247



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.hashMethod, _OVER)




5,550,194✔





248



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfRetensions, _OVER)




5,550,194✔





249



  if (pDb->cfg.numOfRetensions > 0) {




5,550,194✔





250



    pDb->cfg.pRetensions = taosArrayInit(pDb->cfg.numOfRetensions, sizeof(SRetention));




×







251



    if (pDb->cfg.pRetensions == NULL) goto _OVER;




×







252



    for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {




×







253



      SRetention retention = {0};




×







254



      SDB_GET_INT64(pRaw, dataPos, &retention.freq, _OVER)




×







255



      SDB_GET_INT64(pRaw, dataPos, &retention.keep, _OVER)




×







256



      SDB_GET_INT8(pRaw, dataPos, &retention.freqUnit, _OVER)




×







257



      SDB_GET_INT8(pRaw, dataPos, &retention.keepUnit, _OVER)




×







258



      if (taosArrayPush(pDb->cfg.pRetensions, &retention) == NULL) {




×








UNCOV

259



        goto _OVER;




×







260



      }










261



    }










262



  }










263



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.schemaless, _OVER)




5,550,194✔





264



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRetentionPeriod, _OVER)




5,550,194✔





265



  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walRetentionSize, _OVER)




5,550,194✔





266



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRollPeriod, _OVER)




5,550,194✔





267



  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walSegmentSize, _OVER)




5,550,194✔





268



  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.sstTrigger, _OVER)




5,550,194✔





269



  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER)




5,550,194✔





270



  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER)




5,550,194✔





271



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER)




5,550,194✔





272



  SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER)




5,550,194✔





273



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.keepTimeOffset, _OVER)




5,550,194✔





274



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.ssChunkSize, _OVER)




5,550,194✔





275



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.ssKeepLocal, _OVER)




5,550,194✔





276



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.ssCompact, _OVER)




5,550,194✔





277



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.withArbitrator, _OVER)




5,550,194✔





278



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.encryptAlgorithm, _OVER)




5,550,194✔





279



  SDB_GET_INT32(pRaw, dataPos, &pDb->tsmaVersion, _OVER);




5,550,194✔





280



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compactTimeOffset, _OVER)




5,550,194✔





281



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactStartTime, _OVER)




5,550,194✔





282



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactEndTime, _OVER)




5,550,194✔





283



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactInterval, _OVER)




5,550,194✔





284



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.isAudit, _OVER)




5,550,194✔





285



  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.secureDelete, _OVER)




5,550,194✔





286



  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheLastShardBits, _OVER)




5,550,194✔





287












288



  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




5,550,194✔





289



  if (dataPos + sizeof(uint8_t) <= pRaw->dataLen) {




5,550,194✔





290



    SDB_GET_UINT8(pRaw, dataPos, &pDb->cfg.flags, _OVER)




5,550,194✔





291



  }










292



  if (dataPos + sizeof(int64_t) <= pRaw->dataLen) {




5,550,194✔





293



    SDB_GET_INT64(pRaw, dataPos, &pDb->ownerId, _OVER)




5,550,194✔





294



  }










295












296



  taosInitRWLatch(&pDb->lock);




5,550,194✔





297












298



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




5,550,194✔






UNCOV

299



    pDb->cfg.ssChunkSize = TSDB_DEFAULT_SS_CHUNK_SIZE;




×







300













UNCOV

301



    mInfo("db:%s, ssChunkSize set from %d to default %d", pDb->name, pDb->cfg.ssChunkSize, TSDB_DEFAULT_SS_CHUNK_SIZE);




×







302



  }










303












304



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




5,550,194✔






UNCOV

305



    pDb->cfg.ssKeepLocal = TSDB_DEFAULT_SS_KEEP_LOCAL;




×







306













UNCOV

307



    mInfo("db:%s, ssKeepLocal set from %d to default %d", pDb->name, pDb->cfg.ssKeepLocal, TSDB_DEFAULT_SS_KEEP_LOCAL);




×







308



  }










309












310



  if (pDb->cfg.tsdbPageSize != TSDB_MIN_TSDB_PAGESIZE) {




5,550,194✔





311



    mInfo("db:%s, tsdbPageSize set from %d to default %d", pDb->name, pDb->cfg.tsdbPageSize,




5,550,194✔





312



          TSDB_DEFAULT_TSDB_PAGESIZE);










313



  }










314












315



  if (pDb->cfg.sstTrigger != TSDB_MIN_STT_TRIGGER) {




5,550,194✔





316



    mInfo("db:%s, sstTrigger set from %d to default %d", pDb->name, pDb->cfg.sstTrigger, TSDB_DEFAULT_SST_TRIGGER);




5,421,095✔





317



  }










318












319



  if (sver < DB_VER_SUPPORT_ADVANCED_SECURITY) {




5,550,194✔






UNCOV

320



    pDb->cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




×







321



  }










322












323



  terrno = 0;




5,550,194✔





324












325



_OVER:




5,550,194✔





326



  if (terrno != 0) {




5,550,194✔





327



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




×







328



    taosMemoryFreeClear(pRow);




×








UNCOV

329



    return NULL;




×







330



  }










331












332



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




5,550,194✔





333



  return pRow;




5,550,194✔





334



}










335












336



static int32_t mndNewDbActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *pRaw) {




1,265,250✔





337



  SSdb    *pSdb = pMnode->pSdb;




1,265,250✔





338



  SSdbRow *pRow = NULL;




1,265,250✔





339



  SDbObj  *pNewDb = NULL;




1,265,250✔





340



  int      code = -1;




1,265,250✔





341












342



  pRow = mndDbActionDecode(pRaw);




1,265,250✔





343



  if (pRow == NULL) {




1,265,250✔





344



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







345



    if (terrno != 0) code = terrno;




×








UNCOV

346



    goto _OVER;




×







347



  }










348



  pNewDb = sdbGetRowObj(pRow);




1,265,250✔





349



  if (pNewDb == NULL) {




1,265,250✔





350



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







351



    if (terrno != 0) code = terrno;




×








UNCOV

352



    goto _OVER;




×







353



  }










354












355



  SDbObj *pOldDb = sdbAcquire(pMnode->pSdb, SDB_DB, pNewDb->name);




1,265,250✔





356



  if (pOldDb != NULL) {




1,265,250✔





357



    mError("trans:%d, db name already in use. name: %s", pTrans->id, pNewDb->name);




×







358



    sdbRelease(pMnode->pSdb, pOldDb);




×







359



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







360



    if (terrno != 0) code = terrno;




×








UNCOV

361



    goto _OVER;




×







362



  }










363












364



  code = 0;




1,265,250✔





365



_OVER:




1,265,250✔





366



  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);




1,265,250✔





367



  taosMemoryFreeClear(pRow);




1,265,250✔





368



  return code;




1,265,250✔





369



}










370












371



static int32_t mndDbActionInsert(SSdb *pSdb, SDbObj *pDb) {




1,417,756✔





372



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




1,417,756✔





373



  return 0;




1,417,756✔





374



}










375












376



static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {




5,550,194✔





377



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




5,550,194✔





378



  taosArrayDestroy(pDb->cfg.pRetensions);




5,550,194✔





379



  return 0;




5,550,194✔





380



}










381












382



static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {




2,189,837✔





383



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




2,189,837✔





384



  taosWLockLatch(&pOld->lock);




2,189,837✔





385



  pOld->updateTime = pNew->updateTime;




2,189,837✔





386



  pOld->cfgVersion = pNew->cfgVersion;




2,189,837✔





387



  pOld->vgVersion = pNew->vgVersion;




2,189,837✔





388



  pOld->cfg.numOfVgroups = pNew->cfg.numOfVgroups;




2,189,837✔





389



  pOld->cfg.buffer = pNew->cfg.buffer;




2,189,837✔





390



  pOld->cfg.pageSize = pNew->cfg.pageSize;




2,189,837✔





391



  pOld->cfg.pages = pNew->cfg.pages;




2,189,837✔





392



  pOld->cfg.cacheLastSize = pNew->cfg.cacheLastSize;




2,189,837✔





393



  pOld->cfg.cacheLastShardBits = pNew->cfg.cacheLastShardBits;




2,189,837✔





394



  pOld->cfg.daysPerFile = pNew->cfg.daysPerFile;




2,189,837✔





395



  pOld->cfg.daysToKeep0 = pNew->cfg.daysToKeep0;




2,189,837✔





396



  pOld->cfg.daysToKeep1 = pNew->cfg.daysToKeep1;




2,189,837✔





397



  pOld->cfg.daysToKeep2 = pNew->cfg.daysToKeep2;




2,189,837✔





398



  pOld->cfg.keepTimeOffset = pNew->cfg.keepTimeOffset;




2,189,837✔





399



  pOld->cfg.walFsyncPeriod = pNew->cfg.walFsyncPeriod;




2,189,837✔





400



  pOld->cfg.walLevel = pNew->cfg.walLevel;




2,189,837✔





401



  pOld->cfg.walRetentionPeriod = pNew->cfg.walRetentionPeriod;




2,189,837✔





402



  pOld->cfg.walRetentionSize = pNew->cfg.walRetentionSize;




2,189,837✔





403



  pOld->cfg.strict = pNew->cfg.strict;




2,189,837✔





404



  pOld->cfg.cacheLast = pNew->cfg.cacheLast;




2,189,837✔





405



  pOld->cfg.replications = pNew->cfg.replications;




2,189,837✔





406



  pOld->cfg.sstTrigger = pNew->cfg.sstTrigger;




2,189,837✔





407



  pOld->cfg.minRows = pNew->cfg.minRows;




2,189,837✔





408



  pOld->cfg.maxRows = pNew->cfg.maxRows;




2,189,837✔





409



  pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize;




2,189,837✔





410



  pOld->cfg.ssChunkSize = pNew->cfg.ssChunkSize;




2,189,837✔





411



  pOld->cfg.ssKeepLocal = pNew->cfg.ssKeepLocal;




2,189,837✔





412



  pOld->cfg.ssCompact = pNew->cfg.ssCompact;




2,189,837✔





413



  pOld->cfg.withArbitrator = pNew->cfg.withArbitrator;




2,189,837✔





414



  pOld->cfg.compactInterval = pNew->cfg.compactInterval;




2,189,837✔





415



  pOld->cfg.compactStartTime = pNew->cfg.compactStartTime;




2,189,837✔





416



  pOld->cfg.compactEndTime = pNew->cfg.compactEndTime;




2,189,837✔





417



  pOld->cfg.compactTimeOffset = pNew->cfg.compactTimeOffset;




2,189,837✔





418



  pOld->compactStartTime = pNew->compactStartTime;




2,189,837✔





419



  pOld->tsmaVersion = pNew->tsmaVersion;




2,189,837✔





420



  pOld->cfg.isAudit = pNew->cfg.isAudit;




2,189,837✔





421



  pOld->cfg.secureDelete = pNew->cfg.secureDelete;




2,189,837✔





422



  pOld->cfg.flags = pNew->cfg.flags;




2,189,837✔





423



  pOld->ownerId = pNew->ownerId;




2,189,837✔





424



  taosWUnLockLatch(&pOld->lock);




2,189,837✔





425



  return 0;




2,189,837✔





426



}










427












428



static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {




8,930,273✔





429



  SSdb *pSdb = pMnode->pSdb;




8,930,273✔





430



  return sdbGetTableVer(pSdb, SDB_VGROUP);




8,930,273✔





431



}










432












433



SDbObj *mndAcquireDb(SMnode *pMnode, const char *db) {




93,505,898✔





434



  SSdb   *pSdb = pMnode->pSdb;




93,505,898✔





435



  SDbObj *pDb = sdbAcquire(pSdb, SDB_DB, db);




93,505,943✔





436



  if (pDb == NULL) {




93,505,943✔





437



    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {




3,129,777✔





438



      terrno = TSDB_CODE_MND_DB_NOT_EXIST;




2,930,019✔





439



    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {




199,758✔





440



      terrno = TSDB_CODE_MND_DB_IN_CREATING;




5,508✔





441



    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {




194,250✔





442



      terrno = TSDB_CODE_MND_DB_IN_DROPPING;




194,250✔





443



    } else {











UNCOV

444



      terrno = TSDB_CODE_APP_ERROR;




×








UNCOV

445



      mFatal("db:%s, failed to acquire db since %s", db, terrstr());




×







446



    }










447



  }










448



  return pDb;




93,505,925✔





449



}










450












451



SDbObj *mndAcquireAuditDb(SMnode *pMnode) {




44,982,091✔





452



  SSdb      *pSdb = pMnode->pSdb;




44,982,091✔





453



  SDbObj    *pDb = NULL;




44,982,091✔





454



  void      *pIter = NULL;




44,982,091✔





455



  ESdbStatus objStatus = 0;




44,982,091✔





456












457



  while (1) {










458



    pIter = sdbFetchAll(pSdb, SDB_DB, pIter, (void **)&pDb, &objStatus, true);




125,064,485✔





459



    if (pIter == NULL) break;




125,064,485✔





460



    if (pDb->cfg.isAudit == 1) {




80,084,378✔





461



      sdbCancelFetch(pSdb, pIter);




1,984✔





462



      break;




1,984✔





463



    }










464












465



    sdbRelease(pSdb, pDb);




80,082,394✔





466



  }










467



  return pDb;




44,982,091✔





468



}










469












470



void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {




102,253,290✔





471



  SSdb *pSdb = pMnode->pSdb;




102,253,290✔





472



  sdbRelease(pSdb, pDb);




102,253,290✔





473



}




102,254,758✔





474












475



bool mndDbIsExist(SMnode *pMnode, const char *db, int64_t uid) {




161,834✔





476



  SDbObj *pDb = mndAcquireDb(pMnode, db);




161,834✔





477



  if (pDb == NULL) {




161,834✔





478



    return false;




1,700✔





479



  } else {










480



    bool result = (uid == 0) || (uid == pDb->uid);




160,134✔





481



    mndReleaseDb(pMnode, pDb);




160,134✔





482



    pDb = NULL;




160,134✔





483



    return result;




160,134✔





484



  }










485



}










486












487



int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {




1,234,747✔





488



  char *pos = strstr(dbName, TS_PATH_DELIMITER);




1,234,747✔





489



  if (pos == NULL) {




1,234,747✔






UNCOV

490



    return TSDB_CODE_MND_INVALID_DB;




×







491



  }










492












493



  int32_t acctId;




1,232,455✔





494



  int32_t code = taosStr2int32(dbName, &acctId);




1,234,747✔





495



  if (code != 0) {




1,234,747✔






UNCOV

496



    return code;




×







497



  }










498












499



  if (acctId != pUser->acctId) {




1,234,747✔






UNCOV

500



    return TSDB_CODE_MND_INVALID_DB_ACCT;




×







501



  }










502












503



  return 0;




1,234,747✔





504



}










505












506



int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {




1,234,747✔





507



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




1,234,747✔





508












509



  if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return code;




1,234,747✔





510



  if (pCfg->numOfStables < TSDB_DB_STREAM_MODE_OFF || pCfg->numOfStables > TSDB_DB_STREAM_MODE_ON) return code;




1,234,747✔





511



  if (pCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;




1,234,747✔





512



  if (pCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;




1,234,747✔





513



  if (pCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;




1,234,747✔





514



  if (pCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;




1,234,747✔





515



  if (pCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




1,234,747✔





516



      pCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




1,233,243✔





517



    return code;




3,760✔





518



  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;




1,230,987✔





519



  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;




1,230,987✔





520



  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;




1,230,987✔





521



  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;




1,230,987✔





522



  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return code;




1,230,987✔





523



  if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return code;




1,230,987✔





524



  if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return code;




1,230,987✔





525



  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return code;




1,230,987✔





526



  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;




1,230,987✔





527



  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;




1,230,987✔





528



  if (pCfg->minRows > pCfg->maxRows) return code;




1,230,987✔





529



  if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;




1,230,234✔





530



  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;




1,230,234✔





531



  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return code;




1,230,234✔





532



  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return code;




1,230,234✔





533



  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return code;




1,230,234✔





534



#ifdef TD_ENTERPRISE










535



  if ((pCfg->replications == 2) ^ (pCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;




1,230,234✔





536



  // if (pCfg->encryptAlgorithm < TSDB_MIN_ENCRYPT_ALGO || pCfg->encryptAlgorithm > TSDB_MAX_ENCRYPT_ALGO) return code;










537



#else










538



  if (pCfg->replications != 1 && pCfg->replications != 3) return code;










539



  if (pCfg->encryptAlgorithm != TSDB_DEFAULT_ENCRYPT_ALGO) return code;










540



#endif










541












542



  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return code;




1,230,234✔





543



  if (pCfg->schemaless < TSDB_DB_SCHEMALESS_OFF || pCfg->schemaless > TSDB_DB_SCHEMALESS_ON) return code;




1,230,234✔





544



  if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;




1,230,234✔





545



  if (pCfg->hashMethod != 1) return code;




1,230,234✔





546



  if (pCfg->replications > mndGetDnodeSize(pMnode)) {




1,230,234✔






UNCOV

547



    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×








UNCOV

548



    TAOS_RETURN(code);




×







549



  }










550



  if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;




1,230,234✔





551



  if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;




1,230,234✔





552



  if (pCfg->walRollPeriod < TSDB_DB_MIN_WAL_ROLL_PERIOD) return code;




1,230,234✔





553



  if (pCfg->walSegmentSize < TSDB_DB_MIN_WAL_SEGMENT_SIZE) return code;




1,230,234✔





554



  if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return code;




1,230,234✔





555



  if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return code;




1,230,234✔





556



  if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return code;




1,230,234✔





557



  if ((pCfg->hashSuffix * pCfg->hashPrefix) < 0) return code;




1,230,234✔





558



  if ((pCfg->hashPrefix + pCfg->hashSuffix) >= (TSDB_TABLE_NAME_LEN - 1)) return code;




1,230,234✔





559



  if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return code;




1,230,234✔





560



  if (taosArrayGetSize(pCfg->pRetensions) != pCfg->numOfRetensions) return code;




1,230,234✔





561












562



  if (pCfg->ssChunkSize < TSDB_MIN_SS_CHUNK_SIZE || pCfg->ssChunkSize > TSDB_MAX_SS_CHUNK_SIZE) return code;




1,230,234✔





563



  if (pCfg->ssKeepLocal < TSDB_MIN_SS_KEEP_LOCAL || pCfg->ssKeepLocal > TSDB_MAX_SS_KEEP_LOCAL) return code;




1,230,234✔





564



  if (pCfg->ssCompact < TSDB_MIN_SS_COMPACT || pCfg->ssCompact > TSDB_MAX_SS_COMPACT) return code;




1,230,234✔





565












566



  if (pCfg->compactInterval != 0 &&




1,230,234✔





567



      (pCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pCfg->compactInterval > pCfg->daysToKeep2))




3,758✔






UNCOV

568



    return code;




×







569



  if (pCfg->compactStartTime != 0 &&




1,230,234✔





570



      (pCfg->compactStartTime < -pCfg->daysToKeep2 || pCfg->compactStartTime > -pCfg->daysPerFile))




4,147✔





571



    return code;




×







572



  if (pCfg->compactEndTime != 0 &&




1,230,234✔





573



      (pCfg->compactEndTime < -pCfg->daysToKeep2 || pCfg->compactEndTime > -pCfg->daysPerFile))




4,147✔






UNCOV

574



    return code;




×







575



  if (pCfg->compactStartTime != 0 && pCfg->compactEndTime != 0 && pCfg->compactStartTime >= pCfg->compactEndTime)




1,230,234✔






UNCOV

576



    return code;




×







577



  if (pCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET || pCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)




1,230,234✔






UNCOV

578



    return code;




×







579



  if (pCfg->isAudit < 0 || pCfg->isAudit > 1) return code;




1,230,234✔





580



  if (pCfg->allowDrop < TSDB_MIN_DB_ALLOW_DROP || pCfg->allowDrop > TSDB_MAX_DB_ALLOW_DROP) return code;










581












582



  code = 0;




1,230,234✔





583



  TAOS_RETURN(code);




1,230,234✔





584



}










585












586



static int32_t mndCheckInChangeDbCfg(SMnode *pMnode, SDbCfg *pOldCfg, SDbCfg *pNewCfg) {




87,466✔





587



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




87,466✔





588



  if (pNewCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pNewCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;




87,466✔





589



  if (pNewCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pNewCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;




87,466✔





590



  if (pNewCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pNewCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;




87,466✔





591



  if (pNewCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pNewCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;




87,466✔





592



  if (pNewCfg->daysToKeep0 < TSDB_MIN_KEEP || pNewCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;




87,466✔





593



  if (pNewCfg->daysToKeep1 < TSDB_MIN_KEEP || pNewCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;




87,466✔





594



  if (pNewCfg->daysToKeep2 < TSDB_MIN_KEEP || pNewCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;




87,466✔





595



  if (pNewCfg->daysToKeep0 < pNewCfg->daysPerFile) return code;




87,466✔





596



  if (pNewCfg->daysToKeep0 > pNewCfg->daysToKeep1) return code;




87,466✔





597



  if (pNewCfg->daysToKeep1 > pNewCfg->daysToKeep2) return code;




87,466✔





598



  if (pNewCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pNewCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET)




87,466✔






UNCOV

599



    return code;




×







600



  if (pNewCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pNewCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;




87,466✔





601



  if (pNewCfg->walLevel < TSDB_MIN_WAL_LEVEL || pNewCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;




87,466✔





602



  if (pNewCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pNewCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;




87,466✔





603



  if (pNewCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pNewCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;




87,466✔





604



  if (pNewCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




87,466✔





605



      pNewCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




87,466✔






UNCOV

606



    return code;




×







607



  if (pNewCfg->replications < TSDB_MIN_DB_REPLICA || pNewCfg->replications > TSDB_MAX_DB_REPLICA) return code;




87,466✔





608



#ifdef TD_ENTERPRISE










609



  if ((pNewCfg->replications == 2) ^ (pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;




87,466✔





610



  if (pNewCfg->replications == 2 && pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR) {




87,466✔





611



    if (pOldCfg->replications != 1 && pOldCfg->replications != 2) {




738✔





612



      terrno = TSDB_CODE_OPS_NOT_SUPPORT;




738✔





613



      return code;




738✔





614



    }










615



  }










616



  if (pNewCfg->replications != 2 && pOldCfg->replications == 2) {




86,728✔





617



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;




×







618



    return code;




×







619



  }










620



#else










621



  if (pNewCfg->replications != 1 && pNewCfg->replications != 3) return code;










622



#endif










623












624



  if (pNewCfg->walLevel == 0 && pOldCfg->replications > 1) {




86,728✔






UNCOV

625



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×








UNCOV

626



    return code;




×







627



  }










628



  if (pNewCfg->replications > 1 && pOldCfg->walLevel == 0) {




86,728✔






UNCOV

629



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×








UNCOV

630



    return code;




×







631



  }










632












633



  if (pNewCfg->sstTrigger != pOldCfg->sstTrigger &&




86,728✔





634



      (pNewCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pNewCfg->sstTrigger > TSDB_MAX_STT_TRIGGER))




1,286✔





635



    return code;




×







636



  if (pNewCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pNewCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;




86,728✔





637



  if (pNewCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pNewCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;




86,728✔





638



  if (pNewCfg->minRows > pNewCfg->maxRows) return code;




86,728✔





639



  if (pNewCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;




85,990✔





640



  if (pNewCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;




85,990✔





641



  if (pNewCfg->strict < TSDB_DB_STRICT_OFF || pNewCfg->strict > TSDB_DB_STRICT_ON) return code;




85,990✔





642



  if (pNewCfg->replications > mndGetDnodeSize(pMnode)) {




85,990✔






UNCOV

643



    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×







644



    return code;




×







645



  }










646



  if (pNewCfg->ssChunkSize < TSDB_MIN_SS_CHUNK_SIZE || pNewCfg->ssChunkSize > TSDB_MAX_SS_CHUNK_SIZE) return code;




85,990✔





647



  if (pNewCfg->ssKeepLocal < TSDB_MIN_SS_KEEP_LOCAL || pNewCfg->ssKeepLocal > TSDB_MAX_SS_KEEP_LOCAL) return code;




85,990✔





648



  if (pNewCfg->ssCompact < TSDB_MIN_SS_COMPACT || pNewCfg->ssCompact > TSDB_MAX_SS_COMPACT) return code;




85,990✔





649












650



  if (pNewCfg->compactInterval != 0 &&




85,990✔





651



      (pNewCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pNewCfg->compactInterval > pNewCfg->daysToKeep2))




6,750✔






UNCOV

652



    return code;




×







653



  if (pNewCfg->compactStartTime != 0 &&




85,990✔





654



      (pNewCfg->compactStartTime < -pNewCfg->daysToKeep2 || pNewCfg->compactStartTime > -pNewCfg->daysPerFile))




4,536✔






UNCOV

655



    return code;




×







656



  if (pNewCfg->compactEndTime != 0 &&




85,990✔





657



      (pNewCfg->compactEndTime < -pNewCfg->daysToKeep2 || pNewCfg->compactEndTime > -pNewCfg->daysPerFile))




4,536✔






UNCOV

658



    return code;




×







659



  if (pNewCfg->compactStartTime != 0 && pNewCfg->compactEndTime != 0 &&




85,990✔





660



      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)




4,536✔






UNCOV

661



    return code;




×







662



  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||




85,990✔





663



      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)




85,990✔






UNCOV

664



    return code;




×







665



  if (pNewCfg->isAudit < 0 || pNewCfg->isAudit > 1) return code;




85,990✔





666



  if (pNewCfg->allowDrop < TSDB_MIN_DB_ALLOW_DROP || pNewCfg->allowDrop > TSDB_MAX_DB_ALLOW_DROP) return code;










667












668



  code = 0;




85,990✔





669



  TAOS_RETURN(code);




85,990✔





670



}










671












672



static void mndSetDefaultDbCfg(SDbCfg *pCfg) {




1,234,179✔





673



  if (pCfg->numOfVgroups < 0) pCfg->numOfVgroups = TSDB_DEFAULT_VN_PER_DB;




1,234,179✔





674



  if (pCfg->numOfStables < 0) pCfg->numOfStables = TSDB_DEFAULT_DB_SINGLE_STABLE;




1,234,179✔





675



  if (pCfg->buffer < 0) pCfg->buffer = TSDB_DEFAULT_BUFFER_PER_VNODE;




1,234,179✔





676



  if (pCfg->pageSize < 0) pCfg->pageSize = TSDB_DEFAULT_PAGESIZE_PER_VNODE;




1,234,179✔





677



  if (pCfg->pages < 0) pCfg->pages = TSDB_DEFAULT_PAGES_PER_VNODE;




1,234,179✔





678



  if (pCfg->daysPerFile < 0) pCfg->daysPerFile = TSDB_DEFAULT_DURATION_PER_FILE;




1,234,179✔





679



  if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;




1,234,179✔





680



  if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep0;




1,234,179✔





681



  if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = pCfg->daysToKeep1;




1,234,179✔





682



  if (pCfg->keepTimeOffset < 0) pCfg->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;




1,234,179✔





683



  if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MINROWS_FBLOCK;




1,234,179✔





684



  if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;




1,234,179✔





685



  if (pCfg->walFsyncPeriod < 0) pCfg->walFsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;




1,234,179✔





686



  if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;




1,234,179✔





687



  if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;




1,234,179✔





688



  if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;




1,234,179✔





689



  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA;




1,234,179✔





690



  if (pCfg->strict < 0) pCfg->strict = TSDB_DEFAULT_DB_STRICT;




1,234,179✔





691



  if (pCfg->cacheLast < 0) pCfg->cacheLast = TSDB_DEFAULT_CACHE_MODEL;




1,234,179✔





692



  if (pCfg->cacheLastSize <= 0) pCfg->cacheLastSize = TSDB_DEFAULT_CACHE_SIZE;




1,234,179✔





693



  if (pCfg->numOfRetensions < 0) pCfg->numOfRetensions = 0;




1,234,179✔





694



  if (pCfg->schemaless < 0) pCfg->schemaless = TSDB_DB_SCHEMALESS_OFF;




1,234,179✔





695



  if (pCfg->walRetentionPeriod < 0 && pCfg->walRetentionPeriod != -1)




1,234,179✔






UNCOV

696



    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;




×







697



  if (pCfg->walRetentionSize < 0 && pCfg->walRetentionSize != -1)




1,234,179✔






UNCOV

698



    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;




×







699



  if (pCfg->walRollPeriod < 0) pCfg->walRollPeriod = TSDB_REPS_DEF_DB_WAL_ROLL_PERIOD;




1,234,179✔





700



  if (pCfg->walSegmentSize < 0) pCfg->walSegmentSize = TSDB_DEFAULT_DB_WAL_SEGMENT_SIZE;




1,234,179✔





701



  if (pCfg->sstTrigger <= 0) pCfg->sstTrigger = TSDB_DEFAULT_SST_TRIGGER;




1,234,179✔





702



  if (pCfg->tsdbPageSize <= 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE;




1,234,179✔





703



  if (pCfg->ssChunkSize <= 0) pCfg->ssChunkSize = TSDB_DEFAULT_SS_CHUNK_SIZE;




1,234,179✔





704



  if (pCfg->ssKeepLocal <= 0) pCfg->ssKeepLocal = TSDB_DEFAULT_SS_KEEP_LOCAL;




1,234,179✔





705



  if (pCfg->ssCompact < 0) pCfg->ssCompact = TSDB_DEFAULT_SS_COMPACT;




1,234,179✔





706



  if (pCfg->withArbitrator < 0) pCfg->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR;




1,234,179✔





707



  if (pCfg->encryptAlgorithm < 0) pCfg->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO;




1,234,179✔





708



}




1,234,179✔





709












710



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




1,225,075✔





711



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,225,075✔





712



  if (pDbRaw == NULL) return -1;




1,225,075✔





713












714



  if (mndTransAppendPrepareLog(pTrans, pDbRaw) != 0) return -1;




1,225,075✔





715



  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_CREATING) != 0) return -1;




1,225,075✔





716



  return 0;




1,225,075✔





717



}










718












719



static int32_t mndSetNewVgPrepareActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {




1,224,507✔





720



  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




3,846,126✔





721



    if (mndAddNewVgPrepareAction(pMnode, pTrans, (pVgroups + v)) != 0) return -1;




2,621,619✔





722



  }










723



  return 0;




1,224,507✔





724



}










725












726



static int32_t mndSetCreateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {




×







727



  int32_t  code = 0;




×








UNCOV

728



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




×







729



  if (pDbRaw == NULL) {




×







730



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







731



    if (terrno != 0) code = terrno;




×







732



    TAOS_RETURN(code);




×







733



  }










734



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));




×








UNCOV

735



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));




×







736












737



  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




×








UNCOV

738



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




×








UNCOV

739



    if (pVgRaw == NULL) {




×







740



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







741



      if (terrno != 0) code = terrno;




×







742



      TAOS_RETURN(code);




×







743



    }










744



    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));




×







745



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));




×







746



  }










747













UNCOV

748



  if (pDb->cfg.withArbitrator) {




×







749



    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




×








UNCOV

750



      SVgObj   *pVgObj = pVgroups + v;




×








UNCOV

751



      SArbGroup arbGroup = {0};




×








UNCOV

752



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




×








UNCOV

753



      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));




×







754



    }










755



  }










756












757



  TAOS_RETURN(code);




×







758



}










759












760



static int32_t mndSetCreateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {




1,224,507✔





761



  int32_t  code = 0;




1,224,507✔





762



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,224,507✔





763



  if (pDbRaw == NULL) {




1,224,507✔






UNCOV

764



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

765



    if (terrno != 0) code = terrno;




×







766



    TAOS_RETURN(code);




×







767



  }










768



  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));




1,224,507✔





769



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));




1,224,507✔





770












771



  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




3,846,126✔





772



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,621,619✔





773



    if (pVgRaw == NULL) {




2,621,619✔






UNCOV

774



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

775



      if (terrno != 0) code = terrno;




×








UNCOV

776



      TAOS_RETURN(code);




×







777



    }










778



    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));




2,621,619✔





779



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));




2,621,619✔





780



  }










781












782



  if (pDb->cfg.withArbitrator) {




1,224,507✔





783



    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




10,507✔





784



      SVgObj   *pVgObj = pVgroups + v;




6,365✔





785



      SArbGroup arbGroup = {0};




6,365✔





786



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,365✔





787



      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));




6,365✔





788



    }










789



  }










790












791



  TAOS_RETURN(code);




1,224,507✔





792



}










793












794



static int32_t mndSetCreateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups,




1,224,507✔





795



                                        SUserObj *pUserDuped, SArray *pAuditOwnedDbs) {










796



  int32_t  code = 0;




1,224,507✔





797



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,224,507✔





798



  if (pDbRaw == NULL) {




1,224,507✔






UNCOV

799



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

800



    if (terrno != 0) code = terrno;




×







801



    TAOS_RETURN(code);




×







802



  }










803



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));




1,224,507✔





804



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));




1,224,507✔





805












806



  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




3,846,126✔





807



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,621,619✔





808



    if (pVgRaw == NULL) {




2,621,619✔






UNCOV

809



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

810



      if (terrno != 0) code = terrno;




×








UNCOV

811



      TAOS_RETURN(code);




×







812



    }










813



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));




2,621,619✔





814



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));




2,621,619✔





815



  }










816












817



  if (pDb->cfg.withArbitrator) {




1,224,507✔





818



    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {




10,507✔





819



      SVgObj   *pVgObj = pVgroups + v;




6,365✔





820



      SArbGroup arbGroup = {0};




6,365✔





821



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,365✔





822



      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));




6,365✔





823



    }










824



  }










825












826



  if (pUserDuped) {




1,224,507✔





827



    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);




1,224,507✔





828



    if (pUserRaw == NULL) {




1,224,507✔






UNCOV

829



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







830



      if (terrno != 0) code = terrno;




×







831



      TAOS_RETURN(code);




×







832



    }










833



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));




1,224,507✔





834



    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));




1,224,507✔





835



  }










836












837



  if(pAuditOwnedDbs) {




1,224,507✔





838



    int32_t auditOwnedDbSize = taosArrayGetSize(pAuditOwnedDbs);




×








UNCOV

839



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




×








UNCOV

840



      SUserObj *pAuditUser = (SUserObj *)TARRAY_GET_ELEM(pAuditOwnedDbs, i);




×








UNCOV

841



      SSdbRaw  *pAuditUserRaw = mndUserActionEncode(pAuditUser);




×








UNCOV

842



      if (pAuditUserRaw == NULL) {




×








UNCOV

843



        TAOS_RETURN(terrno ? terrno : TSDB_CODE_MND_RETURN_VALUE_NULL);




×







844



      }











UNCOV

845



      TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pAuditUserRaw));




×








UNCOV

846



      TAOS_CHECK_RETURN(sdbSetRawStatus(pAuditUserRaw, SDB_STATUS_READY));




×







847



    }










848



  }










849












850



  TAOS_RETURN(code);




1,224,507✔





851



}










852












853



static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {




1,224,507✔





854



  int32_t code = 0;




1,224,507✔





855



  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {




3,846,126✔





856



    SVgObj *pVgroup = pVgroups + vg;




2,621,619✔





857












858



    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {




5,505,163✔





859



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




2,883,544✔





860



      TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid));




2,883,544✔





861



    }










862



  }










863












864



  TAOS_RETURN(code);




1,224,507✔





865



}










866












867



static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {




1,224,507✔





868



  int32_t code = 0;




1,224,507✔





869



  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {




3,846,126✔





870



    SVgObj *pVgroup = pVgroups + vg;




2,621,619✔





871












872



    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {




5,505,163✔





873



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




2,883,544✔





874



      TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false));




2,883,544✔





875



    }










876



  }










877












878



  TAOS_RETURN(code);




1,224,507✔





879



}










880












881



/**










882



 * @brief fill audit owned dbs for users with role SYSAUDIT or SYSAUDIT_LOG.










883



 *










884



 * @param pMnode










885



 * @param pOperUser










886



 * @param pDb










887



 * @param pAuditOwnedDbs










888



 * @return int32_t










889



 */










890



static int32_t mndSetAuditOwnedDbs(SMnode *pMnode, SUserObj *pOperUser, SDbObj *pDb, SArray **pAuditOwnedDbs) {




124✔





891



  int32_t   code = 0, lino = 0;




124✔





892



  SSdb     *pSdb = pMnode->pSdb;




124✔





893



  SArray   *auditOwnedDbs = NULL;




124✔





894



  SUserObj *pUser = NULL;




124✔





895



  SUserObj  newUserObj = {0};




124✔





896



  int32_t   sysAuditLen = strlen(TSDB_ROLE_SYSAUDIT) + 1;




124✔





897



  int32_t   sysAuditLogLen = strlen(TSDB_ROLE_SYSAUDIT_LOG) + 1;




124✔





898












899



  void *pIter = NULL;




124✔





900



  while ((pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser))) {




248✔





901



    if (taosHashGetSize(pUser->roles) <= 0) {




124✔






UNCOV

902



      sdbRelease(pSdb, pUser);




×







903



      pUser = NULL;




×







904



      continue;




×







905



    }










906



    if(strncmp(pUser->name, pOperUser->name, TSDB_USER_LEN) == 0) {




124✔





907



      sdbRelease(pSdb, pUser);




124✔





908



      pUser = NULL;




124✔





909



      continue;




124✔





910



    }










911



    if (!taosHashGet(pUser->roles, TSDB_ROLE_SYSAUDIT, sysAuditLen) &&




×







912



        !taosHashGet(pUser->roles, TSDB_ROLE_SYSAUDIT_LOG, sysAuditLogLen)) {




×







913



      sdbRelease(pSdb, pUser);




×







914



      pUser = NULL;




×








UNCOV

915



      continue;




×







916



    }










917



    TAOS_CHECK_EXIT(mndUserDupObj(pUser, &newUserObj));




×







918



    TAOS_CHECK_EXIT(taosHashPut(newUserObj.ownedDbs, pDb->name, strlen(pDb->name) + 1, NULL, 0));




×








UNCOV

919



    if (auditOwnedDbs == NULL) {




×







920



      auditOwnedDbs = taosArrayInit(1, sizeof(SUserObj));




×







921



      if (auditOwnedDbs == NULL) {




×







922



        TAOS_CHECK_EXIT(terrno);




×







923



      }










924



    }











UNCOV

925



    if (!taosArrayPush(auditOwnedDbs, &newUserObj)) {




×








UNCOV

926



      TAOS_CHECK_EXIT(terrno);




×







927



    }











UNCOV

928



    memset(&newUserObj, 0, sizeof(SUserObj));




×








UNCOV

929



    sdbRelease(pSdb, pUser);




×








UNCOV

930



    pUser = NULL;




×







931



  }










932



  *pAuditOwnedDbs = auditOwnedDbs;




124✔





933



  auditOwnedDbs = NULL;




124✔





934



_exit:




124✔





935



  if (auditOwnedDbs != NULL) taosArrayDestroyEx(auditOwnedDbs, (FDelete)mndUserFreeObj);




124✔





936



  sdbRelease(pSdb, pUser);




124✔





937



  sdbCancelFetch(pSdb, pIter);




124✔





938



  mndUserFreeObj(&newUserObj);




124✔





939



  TAOS_RETURN(code);




124✔





940



}










941












942



static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser, SArray *dnodeList) {




1,236,279✔





943



  int32_t  code = 0;




1,236,279✔





944



  SArray  *auditOwnedDbs = NULL;




1,236,279✔





945



  SUserObj newUserObj = {0};




1,236,279✔





946



  SDbObj   dbObj = {0};




1,236,279✔





947



  (void)memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);




1,236,279✔





948



  (void)memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);




1,236,279✔





949



  dbObj.createdTime = taosGetTimestampMs();




1,236,279✔





950



  dbObj.updateTime = dbObj.createdTime;




1,236,279✔





951



  dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);




1,236,279✔





952



  dbObj.cfgVersion = 1;




1,236,279✔





953



  dbObj.vgVersion = 1;




1,236,279✔





954



  dbObj.tsmaVersion = 1;




1,236,279✔





955



  (void)memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);




1,236,279✔





956



  dbObj.ownerId = pUser->uid;




1,236,279✔





957



  dbObj.cfg = (SDbCfg){




2,470,266✔





958



      .numOfVgroups = pCreate->numOfVgroups,




1,236,279✔





959



      .numOfStables = pCreate->numOfStables,




1,236,279✔





960



      .buffer = pCreate->buffer,




1,236,279✔





961



      .pageSize = pCreate->pageSize,




1,236,279✔





962



      .pages = pCreate->pages,




1,236,279✔





963



      .cacheLastSize = pCreate->cacheLastSize,




1,236,279✔





964



      .cacheLastShardBits = pCreate->cacheLastShardBits,




1,236,279✔





965



      .daysPerFile = pCreate->daysPerFile,




1,236,279✔





966



      .daysToKeep0 = pCreate->daysToKeep0,




1,236,279✔





967



      .daysToKeep1 = pCreate->daysToKeep1,




1,236,279✔





968



      .daysToKeep2 = pCreate->daysToKeep2,




1,236,279✔





969



      .keepTimeOffset = pCreate->keepTimeOffset,




1,236,279✔





970



      .minRows = pCreate->minRows,




1,236,279✔





971



      .maxRows = pCreate->maxRows,




1,236,279✔





972



      .walFsyncPeriod = pCreate->walFsyncPeriod,




1,236,279✔





973



      .walLevel = pCreate->walLevel,




1,236,279✔





974



      .precision = pCreate->precision,




1,236,279✔





975



      .compression = pCreate->compression,




1,236,279✔





976



      .replications = pCreate->replications,




1,236,279✔





977



      .strict = pCreate->strict,




1,236,279✔





978



      .cacheLast = pCreate->cacheLast,




1,236,279✔





979



      .hashMethod = 1,










980



      .schemaless = pCreate->schemaless,




1,236,279✔





981



      .walRetentionPeriod = pCreate->walRetentionPeriod,




1,236,279✔





982



      .walRetentionSize = pCreate->walRetentionSize,




1,236,279✔





983



      .walRollPeriod = pCreate->walRollPeriod,




1,236,279✔





984



      .walSegmentSize = pCreate->walSegmentSize,




1,236,279✔





985



      .sstTrigger = pCreate->sstTrigger,




1,236,279✔





986



      .hashPrefix = pCreate->hashPrefix,




1,236,279✔





987



      .hashSuffix = pCreate->hashSuffix,




1,236,279✔





988



      .ssChunkSize = pCreate->ssChunkSize,




1,236,279✔





989



      .ssKeepLocal = pCreate->ssKeepLocal,




1,236,279✔





990



      .ssCompact = pCreate->ssCompact,




1,236,279✔





991



      .tsdbPageSize = pCreate->tsdbPageSize,




1,236,279✔





992



      .withArbitrator = pCreate->withArbitrator,




1,236,279✔





993



      .encryptAlgorithm = pCreate->encryptAlgorithm,




1,236,279✔





994



      .compactInterval = pCreate->compactInterval,




1,236,279✔





995



      .compactStartTime = pCreate->compactStartTime,




1,236,279✔





996



      .compactEndTime = pCreate->compactEndTime,




1,236,279✔





997



      .compactTimeOffset = pCreate->compactTimeOffset,




1,236,279✔





998



      .isAudit = pCreate->isAudit,




1,236,279✔





999



      .secureDelete = pCreate->secureDelete,




1,236,279✔





1000



  };










1001



  if (strlen(pCreate->encryptAlgrName) > 0) {




1,236,279✔





1002



    if (strncasecmp(pCreate->encryptAlgrName, "none", TSDB_ENCRYPT_ALGR_NAME_LEN) == 0) {




6,651✔





1003



      if (pCreate->isAudit == 1) {




3,654✔






UNCOV

1004



        code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




×







1005



        mError("db:%s, failed to create, encrypt algorithm not match for audit db, %s", pCreate->db,




×







1006



               pCreate->encryptAlgrName);











UNCOV

1007



        TAOS_RETURN(code);




×







1008



      }










1009



      dbObj.cfg.encryptAlgorithm = 0;




3,654✔





1010



    } else {










1011



      SEncryptAlgrObj *pEncryptAlgr = mndAcquireEncryptAlgrByAId(pMnode, pCreate->encryptAlgrName);




2,997✔





1012



      if (pEncryptAlgr != NULL) {




2,997✔





1013



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




2,217✔






UNCOV

1014



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×








UNCOV

1015



          mError("db:%s, failed to create, encrypt algorithm not match, %s, expect type %d", pCreate->db,




×







1016



                 pCreate->encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);










1017



          TAOS_RETURN(code);




×







1018



        }










1019



        dbObj.cfg.encryptAlgorithm = pEncryptAlgr->id;




2,217✔





1020



      } else {










1021



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




780✔





1022



        mError("db:%s, failed to create, encrypt algorithm not exist, %s", pCreate->db, pCreate->encryptAlgrName);




780✔





1023



        TAOS_RETURN(code);




780✔





1024



      }










1025



      if (tsDataKey[0] == '\0') {




2,217✔






UNCOV

1026



        code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;




×








UNCOV

1027



        mError("db:%s, failed to create db since %s", pCreate->db, tstrerror(code));




×








UNCOV

1028



        TAOS_RETURN(code);




×







1029



      }










1030



    }










1031



  } else {










1032



    if (pCreate->isAudit == 1) {




1,229,628✔





1033



      code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




1,320✔





1034



      mError("db:%s, failed to create, encrypt algorithm not match for audit db, %s", pCreate->db,




1,320✔





1035



             pCreate->encryptAlgrName);










1036



      TAOS_RETURN(code);




1,320✔





1037



    }










1038



  }










1039



  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;




1,234,179✔





1040



  dbObj.cfg.pRetensions = pCreate->pRetensions;




1,234,179✔





1041












1042



  if (pCreate->isAudit == 1) {




1,234,179✔





1043



    if (dbObj.cfg.daysToKeep2 < 2628000) {




124✔






UNCOV

1044



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×








UNCOV

1045



      mError("db:%s, failed to create, keep not match for audit db, %d", pCreate->db, dbObj.cfg.daysToKeep2);




×








UNCOV

1046



      TAOS_RETURN(code);




×







1047



    }










1048



    if (dbObj.cfg.walLevel != 2) {




124✔






UNCOV

1049



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×








UNCOV

1050



      mError("db:%s, failed to create, walLevel not match for audit db, %d", pCreate->db, dbObj.cfg.walLevel);




×








UNCOV

1051



      TAOS_RETURN(code);




×







1052



    }










1053



    dbObj.cfg.allowDrop = TSDB_MIN_DB_ALLOW_DROP;




124✔





1054



  } else {










1055



    dbObj.cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




1,234,055✔





1056



  }










1057












1058



  mndSetDefaultDbCfg(&dbObj.cfg);




1,234,179✔





1059












1060



  if ((code = mndCheckDbName(dbObj.name, pUser)) != 0) {




1,234,179✔






UNCOV

1061



    mError("db:%s, failed to create, check db name failed, since %s", pCreate->db, tstrerror(code));




×








UNCOV

1062



    TAOS_RETURN(code);




×







1063



  }










1064












1065



  if ((code = mndCheckDbCfg(pMnode, &dbObj.cfg)) != 0) {




1,234,179✔





1066



    mError("db:%s, failed to create, check db cfg failed, since %s", pCreate->db, tstrerror(code));




4,513✔





1067



    TAOS_RETURN(code);




4,513✔





1068



  }










1069












1070



  if (dbObj.cfg.hashPrefix > 0) {




1,229,666✔





1071



    int32_t dbLen = strlen(dbObj.name) + 1;




4,126✔





1072



    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix + dbLen);




4,126✔





1073



    dbObj.cfg.hashPrefix += dbLen;




4,126✔





1074



  } else if (dbObj.cfg.hashPrefix < 0) {




1,225,540✔





1075



    int32_t dbLen = strlen(dbObj.name) + 1;




4,891✔





1076



    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix - dbLen);




4,891✔





1077



    dbObj.cfg.hashPrefix -= dbLen;




4,891✔





1078



  }










1079












1080



  SVgObj *pVgroups = NULL;




1,229,666✔





1081



  if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups, dnodeList)) != 0) {




1,229,666✔





1082



    mError("db:%s, failed to create, alloc vgroup failed, since %s", pCreate->db, terrstr());




5,159✔





1083



    TAOS_RETURN(code);




5,159✔





1084



  }










1085












1086



  // add database privileges for user










1087



  SUserObj *pNewUserDuped = NULL;




1,224,507✔





1088



#if 0










1089



  // We record the DB's owner id instread. The owner has the permission to create objects under the DB, but does not










1090



  // have default permissions on objects created by others .Therefore, readDbs/writeDbs are no longer applicable.










1091



  if (!pUser->superUser) {










1092



    TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);










1093



    TAOS_CHECK_GOTO(taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),










1094



                    NULL, _OVER);










1095



    TAOS_CHECK_GOTO(taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),










1096



                    NULL, _OVER);










1097



    pNewUserDuped = &newUserObj;










1098



  }










1099



#else










1100



  // Considering the efficiency of use db privileges in some scenarios like insert operation, owned DBs is stored.










1101



  bool addOwned = false;




1,224,507✔





1102



  if (dbObj.cfg.isAudit == 1) {




1,224,507✔





1103



    if (taosHashGet(pUser->roles, TSDB_ROLE_SYSAUDIT, strlen(TSDB_ROLE_SYSAUDIT) + 1) ||




124✔






UNCOV

1104



        taosHashGet(pUser->roles, TSDB_ROLE_SYSAUDIT_LOG, strlen(TSDB_ROLE_SYSAUDIT_LOG) + 1)) {




×







1105



      addOwned = true;




124✔





1106



    }










1107



    TAOS_CHECK_GOTO(mndSetAuditOwnedDbs(pMnode, pUser, &dbObj, &auditOwnedDbs), NULL, _OVER);




124✔





1108



  } else {










1109



    addOwned = true;




1,224,383✔





1110



  }










1111



  if (addOwned) {




1,224,507✔





1112



    TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);




1,224,507✔





1113



    TAOS_CHECK_GOTO(taosHashPut(newUserObj.ownedDbs, dbObj.name, strlen(dbObj.name) + 1, NULL, 0), NULL, _OVER);




1,224,507✔





1114



    pNewUserDuped = &newUserObj;




1,224,507✔





1115



  }










1116



#endif










1117












1118



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "create-db");




1,224,507✔





1119



  if (pTrans == NULL) {




1,224,507✔






UNCOV

1120



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1121



    if (terrno != 0) code = terrno;




×








UNCOV

1122



    goto _OVER;




×







1123



  }










1124



  // mndTransSetSerial(pTrans);










1125



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




1,224,507✔





1126












1127



  mndTransSetDbName(pTrans, dbObj.name, NULL);




1,224,507✔





1128



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




1,224,507✔





1129












1130



  void   *pIter = NULL;




1,224,507✔





1131



  STrans *exitTrans = NULL;




1,224,507✔





1132












1133



  if (!pUser->superUser) {




1,224,507✔





1134



    while (1) {










1135



      pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&exitTrans);




3,495✔





1136



      if (pIter == NULL) break;




3,495✔





1137













UNCOV

1138



      if (exitTrans->conflict == TRN_CONFLICT_DB &&




×








UNCOV

1139



          strncmp(exitTrans->opername, "create-db", TSDB_TRANS_OPER_LEN) == 0) {




×








UNCOV

1140



        code = TSDB_CODE_MND_TRANS_CONFLICT;




×








UNCOV

1141



        sdbRelease(pMnode->pSdb, exitTrans);




×








UNCOV

1142



        sdbCancelFetch(pMnode->pSdb, pIter);




×







1143



        goto _OVER;




×







1144



      }










1145













UNCOV

1146



      sdbRelease(pMnode->pSdb, exitTrans);




×







1147



    }










1148



  }










1149












1150



  if (dbObj.cfg.isAudit) {




1,224,507✔





1151



    if (dbObj.cfg.numOfVgroups > 1) {




124✔






UNCOV

1152



      code = TSDB_CODE_AUDIT_DB_NOT_MULTI_VGROUP;




×








UNCOV

1153



      TAOS_CHECK_GOTO(code, NULL, _OVER);




×







1154



    }










1155



  }










1156












1157



  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);




1,224,507✔





1158



  TAOS_CHECK_GOTO(mndSetCreateDbPrepareAction(pMnode, pTrans, &dbObj), NULL, _OVER);




1,224,507✔





1159



  TAOS_CHECK_GOTO(mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);




1,224,507✔





1160



  TAOS_CHECK_GOTO(mndSetNewVgPrepareActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);




1,224,507✔





1161



  TAOS_CHECK_GOTO(mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);




1,224,507✔





1162



  TAOS_CHECK_GOTO(mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups, pNewUserDuped, auditOwnedDbs), NULL, _OVER);




1,224,507✔





1163



  TAOS_CHECK_GOTO(mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);




1,224,507✔





1164












1165



  if (dbObj.cfg.isAudit) {




1,224,507✔





1166



    if (tsAuditSaveInSelf) {




124✔





1167



      // when create audit database, pVgroups num always is 1










1168



      TAOS_CHECK_GOTO(mndCreateAuditStb(pMnode, &dbObj, pUser, pTrans, pVgroups), NULL, _OVER);




61✔





1169



    }










1170



  }










1171



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




1,224,507✔





1172












1173



_OVER:




1,224,507✔





1174



  taosMemoryFree(pVgroups);




1,224,507✔





1175



  mndUserFreeObj(&newUserObj);




1,224,507✔





1176



  taosArrayDestroyEx(auditOwnedDbs, (FDelete)mndUserFreeObj);




1,224,507✔





1177



  mndTransDrop(pTrans);




1,224,507✔





1178



  TAOS_RETURN(code);




1,224,507✔





1179



}










1180












1181



static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {




1,248,135✔





1182



  int32_t    code = 0;




1,248,135✔





1183



  SSdb      *pSdb = pMnode->pSdb;




1,248,135✔





1184



  SDnodeObj *pDnode = NULL;




1,248,135✔





1185



  void      *pIter = NULL;




1,248,135✔





1186












1187



#if defined(TD_ENTERPRISE) || defined(TD_ASTRA_TODO)










1188



  if (pReq->encryptAlgorithm == TSDB_ENCRYPT_ALGO_NONE) goto _exit;




1,248,135✔





1189



  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB_ENCRYPTION), NULL, _exit);




×







1190



  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {




×







1191



    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1192



    mError("db:%s, failed to check encryption key:%" PRIi8 " in mnode leader since it's not loaded", pReq->db,




×







1193



           tsEncryptionKeyStat);










1194



    goto _exit;




×







1195



  }










1196













UNCOV

1197



  int64_t curMs = taosGetTimestampMs();




×







1198



  while ((pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pDnode))) {




×







1199



    bool online = false;




×







1200



    if ((pDnode->encryptionKeyStat != tsEncryptionKeyStat || pDnode->encryptionKeyChksum != tsEncryptionKeyChksum) &&




×








UNCOV

1201



        (online = mndIsDnodeOnline(pDnode, curMs))) {




×







1202



      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×








UNCOV

1203



      mError("db:%s, failed to check encryption key:%" PRIi8




×







1204



             "-%u in dnode:%d since it's inconsitent with mnode leader:%" PRIi8 "-%u",










1205



             pReq->db, pDnode->encryptionKeyStat, pDnode->encryptionKeyChksum, pDnode->id, tsEncryptionKeyStat,










1206



             tsEncryptionKeyChksum);











UNCOV

1207



      sdbCancelFetch(pSdb, pIter);




×








UNCOV

1208



      sdbRelease(pSdb, pDnode);




×








UNCOV

1209



      break;




×







1210



    }











UNCOV

1211



    sdbRelease(pSdb, pDnode);




×







1212



  }










1213



#else










1214



  if (pReq->encryptAlgorithm != TSDB_ENCRYPT_ALGO_NONE) {










1215



    code = TSDB_CODE_MND_INVALID_DB_OPTION;










1216



    goto _exit;










1217



  }










1218



#endif










1219



_exit:




1,245,843✔





1220



  TAOS_RETURN(code);




1,248,135✔





1221



}










1222












1223



#ifndef TD_ENTERPRISE










1224



int32_t mndCheckDbDnodeList(SMnode *pMnode, char *db, char *dnodeListStr, SArray *dnodeList) {










1225



  if (dnodeListStr[0] != 0) {










1226



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;










1227



    return terrno;










1228



  } else {










1229



    return 0;










1230



  }










1231



}










1232



#endif










1233












1234



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {




1,349,431✔





1235



  SMnode      *pMnode = pReq->info.node;




1,349,431✔





1236



  int32_t      code = -1;




1,349,431✔





1237



  int32_t      lino = 0;




1,349,431✔





1238



  SDbObj      *pDb = NULL;




1,349,431✔





1239



  SUserObj    *pUser = NULL;




1,349,431✔





1240



  SCreateDbReq createReq = {0};




1,349,431✔





1241



  SArray      *dnodeList = NULL;




1,349,431✔





1242



  int64_t      tss = taosGetTimestampMs();




1,349,431✔





1243












1244



  dnodeList = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(int32_t));




1,349,431✔





1245



  TSDB_CHECK_NULL(dnodeList, code, lino, _OVER, TSDB_CODE_OUT_OF_MEMORY);




1,349,431✔





1246












1247



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




1,349,431✔





1248



#ifdef WINDOWS










1249



  if (taosArrayGetSize(createReq.pRetensions) > 0) {










1250



    terrno = TSDB_CODE_MND_INVALID_PLATFORM;










1251



    goto _OVER;










1252



  }










1253



#endif










1254



  mInfo("db:%s, start to create, vgroups:%d, isAudit:%d, daysToKeep2:%d", createReq.db, createReq.numOfVgroups, createReq.isAudit, createReq.daysToKeep2);




1,349,431✔





1255












1256



  pDb = mndAcquireDb(pMnode, createReq.db);




1,349,431✔





1257



  if (pDb != NULL) {




1,349,431✔





1258



    if (createReq.ignoreExist) {




96,008✔





1259



      mInfo("db:%s, already exist, ignore exist is set", createReq.db);




93,637✔





1260



      code = 0;




93,637✔





1261



      goto _OVER;




93,637✔





1262



    } else {










1263



      code = TSDB_CODE_MND_DB_ALREADY_EXIST;




2,371✔





1264



      goto _OVER;




2,371✔





1265



    }










1266



  } else {










1267



    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {




1,253,423✔





1268



      code = terrno;




4,964✔





1269



      goto _OVER;




4,964✔





1270



    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {




1,248,459✔






UNCOV

1271



      goto _OVER;




×







1272



    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {




1,248,459✔





1273



      // continue










1274



    } else {  // TSDB_CODE_APP_ERROR











UNCOV

1275



      goto _OVER;




×







1276



    }










1277



  }










1278












1279



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_CREATE_DB, NULL), &lino, _OVER);




1,248,459✔





1280












1281



  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB), &lino, _OVER);




1,248,135✔





1282












1283



  int32_t nVnodes = createReq.numOfVgroups * createReq.replications;




1,248,135✔





1284



  TAOS_CHECK_GOTO(grantCheckEx(TSDB_GRANT_VNODE, &nVnodes), &lino, _OVER);




1,248,135✔





1285












1286



  if (createReq.replications == 2) {




1,248,135✔





1287



    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), &lino, _OVER);




5,624✔





1288



  }










1289












1290



  TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER);




1,248,135✔





1291












1292



  TAOS_CHECK_GOTO(mndCheckDbDnodeList(pMnode, createReq.db, createReq.dnodeListStr, dnodeList), &lino, _OVER);




1,248,135✔





1293












1294



  TAOS_CHECK_GOTO(mndAcquireUser(pMnode, RPC_MSG_USER(pReq), &pUser), &lino, _OVER);




1,236,279✔





1295












1296



  if (sdbGetSize(pMnode->pSdb, SDB_MOUNT) > 0) {




1,236,279✔






UNCOV

1297



    TAOS_CHECK_GOTO(TSDB_CODE_MND_MOUNT_NOT_EMPTY, &lino, _OVER);




×







1298



  }










1299












1300



  if (createReq.isAudit == 1) {




1,236,279✔





1301



    SDbObj *pAuditDb = mndAcquireAuditDb(pMnode);




1,444✔





1302



    if (pAuditDb != NULL) {




1,444✔






UNCOV

1303



      mndReleaseDb(pMnode, pAuditDb);




×








UNCOV

1304



      mError("db:%s, audit db already exist, %s", createReq.db, pAuditDb->name);




×








UNCOV

1305



      TAOS_CHECK_GOTO(TSDB_CODE_AUDIT_DB_ALREADY_EXIST, &lino, _OVER);




×







1306



    }










1307



    char *realDbName = strchr(createReq.db, '.');




1,444✔





1308



    if (realDbName && strcmp(realDbName + 1, "log") == 0) {




1,444✔






UNCOV

1309



      mError("db:%s, failed to create, db name not allowed for audit db, %s", createReq.db, realDbName + 1);




×








UNCOV

1310



      TAOS_CHECK_GOTO(TSDB_CODE_MND_INVALID_DB, &lino, _OVER);




×







1311



    }










1312



  }










1313












1314



  TAOS_CHECK_GOTO(mndCreateDb(pMnode, pReq, &createReq, pUser, dnodeList), &lino, _OVER);




1,236,279✔





1315



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




1,224,507✔





1316












1317



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




1,224,507✔





1318



    SName name = {0};




1,224,507✔





1319



    if (tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB) < 0)




1,224,507✔






UNCOV

1320



      mError("db:%s, failed to parse db name", createReq.db);




×







1321



    int64_t tse = taosGetTimestampMs();




1,224,507✔





1322



    double  duration = (double)(tse - tss);




1,224,507✔





1323



    duration = duration / 1000;




1,224,507✔





1324



    auditRecord(pReq, pMnode->clusterId, "createDB", name.dbname, "", createReq.sql, createReq.sqlLen, duration, 0);




1,224,507✔





1325



  }










1326












1327



_OVER:




1,347,139✔





1328



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




1,349,431✔





1329



    mError("db:%s, failed to create at line:%d since %s", createReq.db, lino, tstrerror(code));




31,287✔





1330



  }










1331












1332



  mndReleaseDb(pMnode, pDb);




1,349,431✔





1333



  mndReleaseUser(pMnode, pUser);




1,349,431✔





1334



  tFreeSCreateDbReq(&createReq);




1,349,431✔





1335



  taosArrayDestroy(dnodeList);




1,349,431✔





1336












1337



  TAOS_RETURN(code);




1,349,431✔





1338



}










1339












1340



static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {




113,108✔





1341



  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;




113,108✔





1342












1343



  if (pAlter->buffer > 0 && pAlter->buffer != pDb->cfg.buffer) {




113,108✔





1344



    pDb->cfg.buffer = pAlter->buffer;




895✔





1345



    code = 0;




895✔





1346



  }










1347












1348



  if (pAlter->pages > 0 && pAlter->pages != pDb->cfg.pages) {




113,108✔





1349



    pDb->cfg.pages = pAlter->pages;




2,340✔





1350



    code = 0;




2,340✔





1351



  }










1352












1353



  if (pAlter->pageSize > 0 && pAlter->pageSize != pDb->cfg.pageSize) {




113,108✔






UNCOV

1354



    pDb->cfg.pageSize = pAlter->pageSize;




×








UNCOV

1355



    code = 0;




×







1356



  }










1357












1358



  if (pAlter->daysPerFile > 0 && pAlter->daysPerFile != pDb->cfg.daysPerFile) {




113,108✔






UNCOV

1359



    pDb->cfg.daysPerFile = pAlter->daysPerFile;




×








UNCOV

1360



    code = 0;




×







1361



  }










1362












1363



  if (pAlter->daysToKeep0 > 0 && pAlter->daysToKeep0 != pDb->cfg.daysToKeep0) {




113,108✔





1364



    pDb->cfg.daysToKeep0 = pAlter->daysToKeep0;




16,373✔





1365



    code = 0;




16,373✔





1366



  }










1367












1368



  if (pAlter->daysToKeep1 > 0 && pAlter->daysToKeep1 != pDb->cfg.daysToKeep1) {




113,108✔





1369



    pDb->cfg.daysToKeep1 = pAlter->daysToKeep1;




15,630✔





1370



    code = 0;




15,630✔





1371



  }










1372












1373



  if (pAlter->daysToKeep2 > 0 && pAlter->daysToKeep2 != pDb->cfg.daysToKeep2) {




113,108✔





1374



    pDb->cfg.daysToKeep2 = pAlter->daysToKeep2;




12,715✔





1375



    code = 0;




12,715✔





1376



  }










1377












1378



  if (pAlter->keepTimeOffset >= 0 && pAlter->keepTimeOffset != pDb->cfg.keepTimeOffset) {




113,108✔





1379



    pDb->cfg.keepTimeOffset = pAlter->keepTimeOffset;




3,754✔





1380



    code = 0;




3,754✔





1381



  }










1382












1383



  if (pAlter->walFsyncPeriod >= 0 && pAlter->walFsyncPeriod != pDb->cfg.walFsyncPeriod) {




113,108✔





1384



    pDb->cfg.walFsyncPeriod = pAlter->walFsyncPeriod;




8,976✔





1385



    code = 0;




8,976✔





1386



  }










1387












1388



  if (pAlter->walLevel >= 0 && pAlter->walLevel != pDb->cfg.walLevel) {




113,108✔





1389



    pDb->cfg.walLevel = pAlter->walLevel;




8,966✔





1390



    code = 0;




8,966✔





1391



  }










1392












1393



  if (pAlter->strict >= 0 && pAlter->strict != pDb->cfg.strict) {




113,108✔





1394



#if 1











UNCOV

1395



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1396



#else










1397



    pDb->cfg.strict = pAlter->strict;










1398



    code = 0;










1399



#endif










1400



  }










1401












1402



  if (pAlter->cacheLast >= 0 && pAlter->cacheLast != pDb->cfg.cacheLast) {




113,108✔





1403



    pDb->cfg.cacheLast = pAlter->cacheLast;




15,261✔





1404



    code = 0;




15,261✔





1405



  }










1406












1407



  if (pAlter->cacheLastSize > 0 && pAlter->cacheLastSize != pDb->cfg.cacheLastSize) {




113,108✔





1408



    pDb->cfg.cacheLastSize = pAlter->cacheLastSize;




2,432✔





1409



    code = 0;




2,432✔





1410



  }










1411












1412



  if (pAlter->cacheLastShardBits > 0 && pAlter->cacheLastShardBits != pDb->cfg.cacheLastShardBits) {




113,108✔





1413



    pDb->cfg.cacheLastShardBits = pAlter->cacheLastShardBits;




752✔





1414



    code = 0;




752✔





1415



  }










1416












1417



  if (pAlter->replications > 0 && pAlter->replications != pDb->cfg.replications) {




113,108✔





1418



    pDb->cfg.replications = pAlter->replications;




5,964✔





1419



    pDb->vgVersion++;




5,964✔





1420



    code = 0;




5,964✔





1421



  }










1422












1423



  if (pAlter->sstTrigger > 0 && pAlter->sstTrigger != pDb->cfg.sstTrigger) {




113,108✔





1424



    pDb->cfg.sstTrigger = pAlter->sstTrigger;




1,286✔





1425



    pDb->vgVersion++;




1,286✔





1426



    code = 0;




1,286✔





1427



  }










1428












1429



  if (pAlter->minRows > 0 && pAlter->minRows != pDb->cfg.minRows) {




113,108✔





1430



    pDb->cfg.minRows = pAlter->minRows;




1,476✔





1431



    pDb->vgVersion++;




1,476✔





1432



    code = 0;




1,476✔





1433



  }










1434












1435



  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&




113,108✔





1436



      pAlter->walRetentionPeriod != pDb->cfg.walRetentionPeriod) {




13,315✔





1437



    pDb->cfg.walRetentionPeriod = pAlter->walRetentionPeriod;




7,729✔





1438



    pDb->vgVersion++;




7,729✔





1439



    code = 0;




7,729✔





1440



  }










1441












1442



  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&




113,108✔





1443



      pAlter->walRetentionSize != pDb->cfg.walRetentionSize) {




1,518✔





1444



    pDb->cfg.walRetentionSize = pAlter->walRetentionSize;




738✔





1445



    pDb->vgVersion++;




738✔





1446



    code = 0;




738✔





1447



  }










1448












1449



  if (pAlter->ssKeepLocal >= TSDB_MIN_SS_KEEP_LOCAL && pAlter->ssKeepLocal <= TSDB_MAX_SS_KEEP_LOCAL && pAlter->ssKeepLocal != pDb->cfg.ssKeepLocal) {




113,108✔





1450



    pDb->cfg.ssKeepLocal = pAlter->ssKeepLocal;




738✔





1451



    pDb->vgVersion++;




738✔





1452



    code = 0;




738✔





1453



  }










1454












1455



  if (pAlter->ssCompact >= TSDB_MIN_SS_COMPACT && pAlter->ssCompact <= TSDB_MAX_SS_COMPACT && pAlter->ssCompact != pDb->cfg.ssCompact) {




113,108✔





1456



    pDb->cfg.ssCompact = pAlter->ssCompact;




738✔





1457



    pDb->vgVersion++;




738✔





1458



    code = 0;




738✔





1459



  }










1460












1461



  if (pAlter->withArbitrator >= TSDB_MIN_DB_WITH_ARBITRATOR && pAlter->withArbitrator != pDb->cfg.withArbitrator) {




113,108✔





1462



    pDb->cfg.withArbitrator = pAlter->withArbitrator;




738✔





1463



    pDb->vgVersion++;




738✔





1464



    code = 0;




738✔





1465



  }










1466












1467



  if (pAlter->compactInterval >= TSDB_DEFAULT_COMPACT_INTERVAL && pAlter->compactInterval != pDb->cfg.compactInterval) {




113,108✔





1468



    pDb->cfg.compactInterval = pAlter->compactInterval;




5,256✔





1469



    pDb->vgVersion++;




5,256✔





1470



    code = 0;




5,256✔





1471



  }










1472












1473



  bool compactTimeRangeChanged = false;




113,108✔





1474



  if (pAlter->compactStartTime != pDb->cfg.compactStartTime &&




113,108✔





1475



      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||




110,816✔





1476



       pAlter->compactStartTime <= -pDb->cfg.daysPerFile)) {




110,816✔





1477



    pDb->cfg.compactStartTime = pAlter->compactStartTime;




4,536✔





1478



    compactTimeRangeChanged = true;




4,536✔





1479



    code = 0;




4,536✔





1480



  }










1481












1482



  if (pAlter->compactEndTime != pDb->cfg.compactEndTime &&




113,108✔





1483



      (pAlter->compactEndTime == TSDB_DEFAULT_COMPACT_END_TIME || pAlter->compactEndTime <= -pDb->cfg.daysPerFile)) {




110,816✔





1484



    pDb->cfg.compactEndTime = pAlter->compactEndTime;




4,536✔





1485



    compactTimeRangeChanged = true;




4,536✔





1486



    code = 0;




4,536✔





1487



  }










1488



  if(compactTimeRangeChanged) {




113,108✔





1489



    pDb->vgVersion++;




4,536✔





1490



  }










1491












1492



  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&




113,108✔





1493



      pAlter->compactTimeOffset != pDb->cfg.compactTimeOffset) {




9,078✔





1494



    pDb->cfg.compactTimeOffset = pAlter->compactTimeOffset;




3,762✔





1495



    pDb->vgVersion++;




3,762✔





1496



    code = 0;




3,762✔





1497



  }










1498












1499



  if (pAlter->isAudit > -1 && pAlter->isAudit != pDb->cfg.isAudit) {




113,108✔






UNCOV

1500



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×








UNCOV

1501



    return code;




×







1502



  }










1503












1504



  if(pAlter->allowDrop > -1 && pAlter->allowDrop != pDb->cfg.allowDrop) {




113,108✔






UNCOV

1505



    pDb->cfg.allowDrop = pAlter->allowDrop;




×








UNCOV

1506



    code = 0;




×







1507



  }










1508












1509



  if (pAlter->secureDelete > -1 && pAlter->secureDelete != pDb->cfg.secureDelete) {




113,108✔





1510



    pDb->cfg.secureDelete = pAlter->secureDelete;




570✔





1511



    pDb->vgVersion++;




570✔





1512



    code = 0;




570✔





1513



  }










1514












1515



  TAOS_RETURN(code);




113,108✔





1516



}










1517












1518



static int32_t mndSetAlterDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {




85,296✔





1519



  int32_t  code = 0;




85,296✔





1520



  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);




85,296✔





1521



  if (pRedoRaw == NULL) {




85,296✔






UNCOV

1522



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1523



    if (terrno != 0) code = terrno;




×








UNCOV

1524



    TAOS_RETURN(code);




×







1525



  }










1526



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




85,296✔






UNCOV

1527



    sdbFreeRaw(pRedoRaw);




×







1528



    TAOS_RETURN(code);




×







1529



  }










1530












1531



  if ((code = sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY)) != 0) {




85,296✔






UNCOV

1532



    sdbFreeRaw(pRedoRaw);




×







1533



    TAOS_RETURN(code);




×







1534



  }










1535



  return 0;




85,296✔





1536



}










1537












1538



int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {




85,296✔





1539



  int32_t  code = 0;




85,296✔





1540



  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);




85,296✔





1541



  if (pCommitRaw == NULL) {




85,296✔






UNCOV

1542



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1543



    if (terrno != 0) code = terrno;




×








UNCOV

1544



    TAOS_RETURN(code);




×







1545



  }










1546



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




85,296✔






UNCOV

1547



    sdbFreeRaw(pCommitRaw);




×








UNCOV

1548



    TAOS_RETURN(code);




×







1549



  }










1550












1551



  if ((code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)) != 0) {




85,296✔






UNCOV

1552



    sdbFreeRaw(pCommitRaw);




×








UNCOV

1553



    TAOS_RETURN(code);




×







1554



  }










1555



  TAOS_RETURN(code);




85,296✔





1556



}










1557












1558



static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {




85,296✔





1559



  int32_t code = 0, lino = 0;




85,296✔





1560



  SSdb   *pSdb = pMnode->pSdb;




85,296✔





1561



  void   *pIter = NULL;




85,296✔





1562



  SVgObj *pVgroup = NULL;




85,296✔





1563



  SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL);




85,296✔





1564












1565



  TSDB_CHECK_NULL(pArray, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY);




85,296✔





1566












1567



  while (1) {










1568



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




602,796✔





1569



    if (pIter == NULL) break;




602,796✔





1570












1571



    if (mndVgroupInDb(pVgroup, pNewDb->uid)) {




518,226✔





1572



      SVgObj newVgroup = {0};




216,820✔





1573



      TAOS_CHECK_GOTO(mndBuildAlterVgroupAction(pMnode, pTrans, pOldDb, pNewDb, pVgroup, pArray, &newVgroup), &lino,




216,820✔





1574



                      _err);










1575












1576



      if (pNewDb->cfg.withArbitrator != pOldDb->cfg.withArbitrator) {




216,094✔






UNCOV

1577



        if (pNewDb->cfg.withArbitrator) {




×








UNCOV

1578



          SArbGroup arbGroup = {0};




×








UNCOV

1579



          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(&newVgroup, &arbGroup), &lino, _err);




×








UNCOV

1580



          TAOS_CHECK_GOTO(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);




×







1581



        } else {











UNCOV

1582



          SArbGroup arbGroup = {0};




×








UNCOV

1583



          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(pVgroup, &arbGroup), &lino, _err);




×








UNCOV

1584



          TAOS_CHECK_GOTO(mndSetDropArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);




×







1585



        }










1586



      }










1587



    }










1588












1589



    sdbRelease(pSdb, pVgroup);




517,500✔





1590



  }










1591












1592



  taosArrayDestroy(pArray);




84,570✔





1593



  TAOS_RETURN(code);




84,570✔





1594












1595



_err:




726✔





1596



  mError("db:%s, %s failed at %d since %s", pNewDb->name, __func__, lino, tstrerror(code));




726✔





1597












1598



  sdbCancelFetch(pSdb, pIter);




726✔





1599



  sdbRelease(pSdb, pVgroup);




726✔





1600



  taosArrayDestroy(pArray);




726✔





1601



  TAOS_RETURN(code);




726✔





1602



}










1603












1604



static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {




85,990✔





1605



  int32_t code = -1;




85,990✔





1606



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "alter-db");




85,990✔





1607



  if (pTrans == NULL) {




85,990✔






UNCOV

1608



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1609



    if (terrno != 0) code = terrno;




×








UNCOV

1610



    TAOS_RETURN(code);




×







1611



  }










1612



  mInfo("trans:%d, used to alter db:%s", pTrans->id, pOld->name);




85,990✔





1613



  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);




85,990✔





1614












1615



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




85,990✔





1616



  mndTransSetGroupParallel(pTrans);




85,990✔





1617



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




85,990✔





1618



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




85,990✔





1619



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




85,925✔





1620












1621



  TAOS_CHECK_GOTO(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);




85,296✔





1622



  TAOS_CHECK_GOTO(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);




85,296✔





1623



  TAOS_CHECK_GOTO(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew), NULL, _OVER);




85,296✔





1624












1625



  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);




84,570✔





1626



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




84,570✔





1627



  code = 0;




84,570✔





1628












1629



_OVER:




85,990✔





1630



  mndTransDrop(pTrans);




85,990✔





1631



  TAOS_RETURN(code);




85,990✔





1632



}










1633












1634



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {




116,354✔





1635



  SMnode     *pMnode = pReq->info.node;




116,354✔





1636



  int32_t     code = -1;




116,354✔





1637



  SDbObj     *pDb = NULL;




116,354✔





1638



  SAlterDbReq alterReq = {0};




116,354✔





1639



  SDbObj      dbObj = {0};




116,354✔





1640



  int64_t     tss = taosGetTimestampMs();




116,354✔





1641












1642



  TAOS_CHECK_GOTO(tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq), NULL, _OVER);




116,354✔





1643












1644



  mInfo("db:%s, start to alter, encryt_algr:%s", alterReq.db, alterReq.encryptAlgrName);




116,354✔





1645












1646



  pDb = mndAcquireDb(pMnode, alterReq.db);




116,354✔





1647



  if (pDb == NULL) {




116,354✔





1648



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




816✔





1649



    if (terrno != 0) code = terrno;




816✔





1650



    goto _OVER;




816✔





1651



  }










1652












1653



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_ALTER_DB, pDb), NULL, _OVER);




115,538✔





1654












1655



  if (alterReq.replications == 2) {




115,406✔





1656



    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), NULL, _OVER);




738✔





1657



  }










1658












1659



  int32_t numOfTopics = 0;




115,406✔





1660



  TAOS_CHECK_GOTO(mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics), NULL, _OVER);




115,406✔





1661












1662



  if (numOfTopics != 0 && alterReq.walRetentionPeriod == 0) {




115,406✔





1663



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×








UNCOV

1664



    mError("db:%s, not allowed to set WAL_RETENTION_PERIOD 0 when there are topics defined. numOfTopics:%d", pDb->name,




×







1665



           numOfTopics);











UNCOV

1666



    goto _OVER;




×







1667



  }










1668












1669



  if (pDb->cfg.isMount) {




115,406✔





1670



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×








UNCOV

1671



    goto _OVER;




×







1672



  }










1673












1674



  (void)memcpy(&dbObj, pDb, sizeof(SDbObj));




115,406✔





1675



  if (dbObj.cfg.pRetensions != NULL) {




115,406✔






UNCOV

1676



    dbObj.cfg.pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);




×







1677



    if (dbObj.cfg.pRetensions == NULL) goto _OVER;




×







1678



  }










1679












1680



  if (pDb->cfg.isAudit == 1) {




115,406✔






UNCOV

1681



    if (alterReq.daysToKeep2 > -1 && alterReq.daysToKeep2 < 2628000) {




×








UNCOV

1682



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×








UNCOV

1683



      mError("db:%s, failed to alter, keep not match for audit db, %d", alterReq.db, alterReq.daysToKeep2);




×








UNCOV

1684



      goto _OVER;




×







1685



    }











UNCOV

1686



    if (alterReq.walLevel > -1 && alterReq.walLevel != 2) {




×








UNCOV

1687



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×








UNCOV

1688



      mError("db:%s, failed to alter, walLevel not match for audit db, %d", alterReq.db, alterReq.walLevel);




×







1689



      goto _OVER;




×







1690



    }










1691



    if (alterReq.isAudit == 0) {




×








UNCOV

1692



      code = TSDB_CODE_AUDIT_DB_NOT_ALLOW_CHANGE;




×








UNCOV

1693



      mError("db:%s, failed to alter, is not allowed to change audit db, %d", alterReq.db, alterReq.isAudit);




×








UNCOV

1694



      goto _OVER;




×







1695



    }










1696



  }










1697












1698



  if (strlen(alterReq.encryptAlgrName) > 0) {




115,406✔





1699



    mInfo("db:%s, check encryt algr:%s", alterReq.db, alterReq.encryptAlgrName);




3,078✔





1700












1701



    if (strncasecmp(alterReq.encryptAlgrName, "none", TSDB_ENCRYPT_ALGR_NAME_LEN) == 0) {




3,078✔





1702



      if (pDb->cfg.encryptAlgorithm != 0) {




780✔






UNCOV

1703



        code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




×








UNCOV

1704



        mError("db:%s, failed to alter, not allowed to change, %s", alterReq.db, alterReq.encryptAlgrName);




×








UNCOV

1705



        goto _OVER;




×







1706



      }










1707



    } else {










1708



      SEncryptAlgrObj *pEncryptAlgr = mndAcquireEncryptAlgrByAId(pMnode, alterReq.encryptAlgrName);




2,298✔





1709



      if (pEncryptAlgr != NULL) {




2,298✔





1710



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




1,518✔






UNCOV

1711



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×








UNCOV

1712



          mError("db:%s, failed to alter, encrypt algorithm not match, %s, expect type %d", alterReq.db,




×







1713



                 alterReq.encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);











UNCOV

1714



          goto _OVER;




×







1715



        }










1716



        if (pEncryptAlgr->id != pDb->cfg.encryptAlgorithm) {




1,518✔





1717



          code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




1,518✔





1718



          mError("db:%s, failed to alter, not allowed to change, %s", alterReq.db, alterReq.encryptAlgrName);




1,518✔





1719



          goto _OVER;




1,518✔





1720



        }










1721



      } else {










1722



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




780✔





1723



        mError("db:%s, failed to alter, encrypt algorithm not exist, %s", alterReq.db, alterReq.encryptAlgrName);




780✔





1724



        goto _OVER;




780✔





1725



      }










1726



    }










1727



  }










1728












1729



  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);




113,108✔





1730



  if (code != 0) {




113,108✔





1731



    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;




25,642✔





1732



    goto _OVER;




25,642✔





1733



  }










1734












1735



  TAOS_CHECK_GOTO(mndCheckInChangeDbCfg(pMnode, &pDb->cfg, &dbObj.cfg), NULL, _OVER);




87,466✔





1736












1737



  dbObj.cfgVersion++;




85,990✔





1738



  dbObj.updateTime = taosGetTimestampMs();




85,990✔





1739



  code = mndAlterDb(pMnode, pReq, pDb, &dbObj);




85,990✔





1740












1741



  if (dbObj.cfg.replications != pDb->cfg.replications) {




85,990✔





1742



    // return quickly, operation executed asynchronously










1743



    mInfo("db:%s, alter db replica from %d to %d", pDb->name, pDb->cfg.replications, dbObj.cfg.replications);




5,226✔





1744



  } else {










1745



    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




80,764✔





1746



  }










1747












1748



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




85,990✔





1749



    SName name = {0};




85,990✔





1750



    if (tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB) < 0)




85,990✔






UNCOV

1751



      mError("db:%s, failed to parse db name", alterReq.db);




×







1752












1753



    int64_t tse = taosGetTimestampMs();




85,990✔





1754



    double  duration = (double)(tse - tss);




85,990✔





1755



    duration = duration / 1000;




85,990✔





1756



    auditRecord(pReq, pMnode->clusterId, "alterDB", name.dbname, "", alterReq.sql, alterReq.sqlLen, duration, 0);




85,990✔





1757



  }










1758












1759



_OVER:




116,354✔





1760



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




116,354✔





1761



    if (terrno != 0) code = terrno;




6,142✔





1762



    mError("db:%s, failed to alter since %s", alterReq.db, tstrerror(code));




6,142✔





1763



  }










1764












1765



  mndReleaseDb(pMnode, pDb);




116,354✔





1766



  taosArrayDestroy(dbObj.cfg.pRetensions);




116,354✔





1767



  tFreeSAlterDbReq(&alterReq);




116,354✔





1768












1769



  TAOS_RETURN(code);




116,354✔





1770



}










1771












1772



static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb, char *algorithmsId) {




3,982,286✔





1773



  tstrncpy(cfgRsp->db, pDb->name, sizeof(cfgRsp->db));




3,982,286✔





1774



  cfgRsp->dbId = pDb->uid;




3,982,286✔





1775



  cfgRsp->ownerId = pDb->ownerId;




3,981,552✔





1776



  cfgRsp->cfgVersion = pDb->cfgVersion;




3,980,818✔





1777



  cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;




3,981,552✔





1778



  cfgRsp->numOfStables = pDb->cfg.numOfStables;




3,980,818✔





1779



  cfgRsp->buffer = pDb->cfg.buffer;




3,980,818✔





1780



  cfgRsp->cacheSize = pDb->cfg.cacheLastSize;




3,981,552✔





1781



  cfgRsp->cacheShardBits = pDb->cfg.cacheLastShardBits;




3,981,552✔





1782



  cfgRsp->pageSize = pDb->cfg.pageSize;




3,980,818✔





1783



  cfgRsp->pages = pDb->cfg.pages;




3,982,286✔





1784



  cfgRsp->daysPerFile = pDb->cfg.daysPerFile;




3,981,552✔





1785



  cfgRsp->daysToKeep0 = pDb->cfg.daysToKeep0;




3,982,286✔





1786



  cfgRsp->daysToKeep1 = pDb->cfg.daysToKeep1;




3,981,552✔





1787



  cfgRsp->daysToKeep2 = pDb->cfg.daysToKeep2;




3,982,286✔





1788



  cfgRsp->keepTimeOffset = pDb->cfg.keepTimeOffset;




3,981,552✔





1789



  cfgRsp->minRows = pDb->cfg.minRows;




3,981,552✔





1790



  cfgRsp->maxRows = pDb->cfg.maxRows;




3,980,818✔





1791



  cfgRsp->walFsyncPeriod = pDb->cfg.walFsyncPeriod;




3,981,552✔





1792



  cfgRsp->hashPrefix = pDb->cfg.hashPrefix;




3,981,552✔





1793



  cfgRsp->hashSuffix = pDb->cfg.hashSuffix;




3,982,286✔





1794



  cfgRsp->hashMethod = pDb->cfg.hashMethod;




3,981,552✔





1795



  cfgRsp->walLevel = pDb->cfg.walLevel;




3,980,818✔





1796



  cfgRsp->precision = pDb->cfg.precision;




3,981,552✔





1797



  cfgRsp->compression = pDb->cfg.compression;




3,981,552✔





1798



  cfgRsp->replications = pDb->cfg.replications;




3,981,552✔





1799



  cfgRsp->strict = pDb->cfg.strict;




3,981,552✔





1800



  cfgRsp->cacheLast = pDb->cfg.cacheLast;




3,980,818✔





1801



  cfgRsp->tsdbPageSize = pDb->cfg.tsdbPageSize;




3,982,286✔





1802



  cfgRsp->walRetentionPeriod = pDb->cfg.walRetentionPeriod;




3,981,552✔





1803



  cfgRsp->walRollPeriod = pDb->cfg.walRollPeriod;




3,981,552✔





1804



  cfgRsp->walRetentionSize = pDb->cfg.walRetentionSize;




3,981,552✔





1805



  cfgRsp->walSegmentSize = pDb->cfg.walSegmentSize;




3,982,286✔





1806



  cfgRsp->numOfRetensions = pDb->cfg.numOfRetensions;




3,981,552✔





1807



  cfgRsp->pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);




3,981,552✔





1808



  cfgRsp->schemaless = pDb->cfg.schemaless;




3,982,286✔





1809



  cfgRsp->sstTrigger = pDb->cfg.sstTrigger;




3,980,818✔





1810



  cfgRsp->ssChunkSize = pDb->cfg.ssChunkSize;




3,982,286✔





1811



  cfgRsp->ssKeepLocal = pDb->cfg.ssKeepLocal;




3,980,818✔





1812



  cfgRsp->ssCompact = pDb->cfg.ssCompact;




3,981,452✔





1813



  cfgRsp->withArbitrator = pDb->cfg.withArbitrator;




3,981,452✔





1814



  // cfgRsp->encryptAlgr = pDb->cfg.encryptAlgorithm;










1815



  cfgRsp->compactInterval = pDb->cfg.compactInterval;




3,981,452✔





1816



  cfgRsp->compactStartTime = pDb->cfg.compactStartTime;




3,980,718✔





1817



  cfgRsp->compactEndTime = pDb->cfg.compactEndTime;




3,980,818✔





1818



  cfgRsp->compactTimeOffset = pDb->cfg.compactTimeOffset;




3,981,452✔





1819



  cfgRsp->flags = pDb->cfg.flags;




3,981,452✔





1820



  tstrncpy(cfgRsp->algorithmsId, algorithmsId, sizeof(cfgRsp->algorithmsId));




3,981,452✔





1821



  cfgRsp->isAudit = pDb->cfg.isAudit;




3,982,286✔





1822



  cfgRsp->secureDelete = pDb->cfg.secureDelete;




3,981,552✔





1823



}




3,982,286✔





1824












1825



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {




4,865,427✔





1826



  SMnode   *pMnode = pReq->info.node;




4,865,427✔





1827



  int32_t   code = -1;




4,865,427✔





1828



  SDbObj   *pDb = NULL;




4,865,427✔





1829



  SDbCfgReq cfgReq = {0};




4,865,427✔





1830



  SDbCfgRsp cfgRsp = {0};




4,865,427✔





1831












1832



  TAOS_CHECK_GOTO(tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq), NULL, _OVER);




4,865,427✔





1833












1834



  const char *pRealDb = strstr(cfgReq.db, ".");




4,865,427✔





1835



  if (pRealDb) {




4,865,427✔





1836



    ++pRealDb;




4,865,427✔





1837



  } else {











UNCOV

1838



    pRealDb = &cfgReq.db[0];




×







1839



  }










1840



  if (!IS_SYS_DBNAME(pRealDb)) {




4,865,427✔





1841



    pDb = mndAcquireDb(pMnode, cfgReq.db);




4,445,051✔





1842



    if (pDb == NULL) {




4,445,051✔





1843



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




509,349✔





1844



      if (terrno != 0) code = terrno;




509,349✔





1845



      goto _OVER;




509,349✔





1846



    }










1847












1848



    char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




3,935,702✔





1849



    mndGetEncryptOsslAlgrNameById(pMnode, pDb->cfg.encryptAlgorithm, algrId);




3,935,702✔





1850



    mndDumpDbCfgInfo(&cfgRsp, pDb, algrId);




3,935,702✔





1851



  }










1852












1853



  int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);




4,355,344✔





1854



  void   *pRsp = rpcMallocCont(contLen);




4,355,344✔





1855



  if (pRsp == NULL) {




4,354,610✔






UNCOV

1856



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1857



    if (terrno != 0) code = terrno;




×








UNCOV

1858



    goto _OVER;




×







1859



  }










1860












1861



  int32_t ret = 0;




4,354,610✔





1862



  if ((ret = tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp)) < 0) {




4,354,610✔






UNCOV

1863



    code = ret;




×








UNCOV

1864



    goto _OVER;




×







1865



  }










1866












1867



  pReq->info.rsp = pRsp;




4,355,344✔





1868



  pReq->info.rspLen = contLen;




4,355,344✔





1869












1870



  code = 0;




4,355,244✔





1871












1872



_OVER:




4,864,593✔





1873












1874



  tFreeSDbCfgRsp(&cfgRsp);




4,864,693✔





1875












1876



  if (code != 0) {




4,863,959✔





1877



    mError("db:%s, failed to get cfg since %s", cfgReq.db, terrstr());




509,349✔





1878



  }










1879












1880



  mndReleaseDb(pMnode, pDb);




4,863,959✔





1881












1882



  TAOS_RETURN(code);




4,865,427✔





1883



}










1884












1885



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




672,950✔





1886



  int32_t  code = 0;




672,950✔





1887



  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);




672,950✔





1888



  if (pRedoRaw == NULL) {




672,950✔






UNCOV

1889



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1890



    if (terrno != 0) code = terrno;




×







1891



    return -1;




×







1892



  }










1893



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));




672,950✔





1894



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));




672,950✔





1895












1896



  SSdb *pSdb = pMnode->pSdb;




672,950✔





1897



  void *pIter = NULL;




672,950✔





1898












1899



  while (1) {




4,446✔





1900



    SArbGroup *pArbGroup = NULL;




677,396✔





1901



    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);




677,396✔





1902



    if (pIter == NULL) break;




677,396✔





1903












1904



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




4,446✔





1905



      if ((code = mndSetDropArbGroupPrepareLogs(pTrans, pArbGroup)) != 0) {




4,446✔






UNCOV

1906



        sdbCancelFetch(pSdb, pIter);




×







1907



        sdbRelease(pSdb, pArbGroup);




×







1908



        TAOS_RETURN(code);




×







1909



      }










1910



    }










1911












1912



    sdbRelease(pSdb, pArbGroup);




4,446✔





1913



  }










1914












1915



  TAOS_RETURN(code);




672,950✔





1916



}










1917












1918



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




672,950✔





1919



  int32_t  code = 0;




672,950✔





1920



  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);




672,950✔





1921



  if (pCommitRaw == NULL) {




672,950✔






UNCOV

1922



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1923



    if (terrno != 0) code = terrno;




×







1924



    return -1;




×







1925



  }










1926



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));




672,950✔





1927



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));




672,950✔





1928












1929



  SSdb *pSdb = pMnode->pSdb;




672,950✔





1930



  void *pIter = NULL;




672,950✔





1931












1932



  while (1) {




4,446✔





1933



    SArbGroup *pArbGroup = NULL;




677,396✔





1934



    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);




677,396✔





1935



    if (pIter == NULL) break;




677,396✔





1936












1937



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




4,446✔





1938



      if ((code = mndSetDropArbGroupCommitLogs(pTrans, pArbGroup)) != 0) {




4,446✔






UNCOV

1939



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1940



        sdbRelease(pSdb, pArbGroup);




×







1941



        TAOS_RETURN(code);




×







1942



      }










1943



    }










1944












1945



    sdbRelease(pSdb, pArbGroup);




4,446✔





1946



  }










1947












1948



  while (1) {




3,383,903✔





1949



    SVgObj *pVgroup = NULL;




4,056,853✔





1950



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




4,056,853✔





1951



    if (pIter == NULL) break;




4,056,853✔





1952












1953



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




3,383,903✔





1954



      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




1,444,168✔





1955



      if (pVgRaw == NULL) {




1,444,168✔






UNCOV

1956



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1957



        sdbRelease(pSdb, pVgroup);




×








UNCOV

1958



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1959



        if (terrno != 0) code = terrno;




×








UNCOV

1960



        TAOS_RETURN(code);




×







1961



      }










1962



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




1,444,168✔






UNCOV

1963



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1964



        sdbRelease(pSdb, pVgroup);




×








UNCOV

1965



        TAOS_RETURN(code);




×







1966



      }










1967



      if ((code = sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED)) != 0) {




1,444,168✔






UNCOV

1968



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1969



        sdbRelease(pSdb, pVgroup);




×








UNCOV

1970



        TAOS_RETURN(code);




×







1971



      }










1972



    }










1973












1974



    sdbRelease(pSdb, pVgroup);




3,383,903✔





1975



  }










1976












1977



  while (1) {




1,113,070✔





1978



    SStbObj *pStb = NULL;




1,786,020✔





1979



    ESdbStatus status;




1,780,143✔





1980



    pIter = sdbFetchAll(pSdb, SDB_STB, pIter, (void **)&pStb, &status, true);




1,786,020✔





1981



    if (pIter == NULL) break;




1,786,020✔





1982












1983



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




1,113,070✔





1984



      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);




570,862✔





1985



      if (pStbRaw == NULL) {




570,862✔






UNCOV

1986



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1987



        sdbRelease(pSdb, pStbRaw);




×








UNCOV

1988



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1989



        if (terrno != 0) code = terrno;




×








UNCOV

1990



        return -1;




×







1991



      }










1992



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




570,862✔






UNCOV

1993



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1994



        sdbRelease(pSdb, pStbRaw);




×








UNCOV

1995



        return -1;




×







1996



      }










1997



      if ((code = sdbSetRawStatus(pStbRaw, SDB_STATUS_DROPPED)) != 0) {




570,862✔






UNCOV

1998



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1999



        sdbRelease(pSdb, pStbRaw);




×








UNCOV

2000



        return -1;




×







2001



      }










2002



    }










2003












2004



    sdbRelease(pSdb, pStb);




1,113,070✔





2005



  }










2006












2007



  TAOS_RETURN(code);




672,950✔





2008



}










2009












2010



static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {




1,444,168✔





2011



  int32_t code = 0;




1,444,168✔





2012



  for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {




2,957,258✔





2013



    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




1,513,090✔





2014



    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, true));




1,513,090✔





2015



  }










2016












2017



  TAOS_RETURN(code);




1,444,168✔





2018



}










2019












2020



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




672,950✔





2021



  int32_t code = 0;




672,950✔





2022



  SSdb   *pSdb = pMnode->pSdb;




672,950✔





2023



  void   *pIter = NULL;




672,950✔





2024












2025



  while (1) {




3,383,903✔





2026



    SVgObj *pVgroup = NULL;




4,056,853✔





2027



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




4,056,853✔





2028



    if (pIter == NULL) break;




4,056,853✔





2029












2030



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




3,383,903✔





2031



      if ((code = mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup)) != 0) {




1,444,168✔






UNCOV

2032



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

2033



        sdbRelease(pSdb, pVgroup);




×








UNCOV

2034



        TAOS_RETURN(code);




×







2035



      }










2036



    }










2037












2038



    sdbRelease(pSdb, pVgroup);




3,383,903✔





2039



  }










2040












2041



  TAOS_RETURN(code);




672,950✔





2042



}










2043












2044



static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




1,160,715✔





2045



  int32_t    code = 0;




1,160,715✔





2046



  SDropDbRsp dropRsp = {0};




1,160,715✔





2047



  if (pDb != NULL) {




1,160,715✔





2048



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




672,394✔





2049



    dropRsp.uid = pDb->uid;




672,394✔





2050



  }










2051












2052



  int32_t rspLen = tSerializeSDropDbRsp(NULL, 0, &dropRsp);




1,160,715✔





2053



  void   *pRsp = NULL;




1,160,715✔





2054



  if (useRpcMalloc) {




1,160,715✔





2055



    pRsp = rpcMallocCont(rspLen);




488,321✔





2056



  } else {










2057



    pRsp = taosMemoryMalloc(rspLen);




672,394✔





2058



  }










2059












2060



  if (pRsp == NULL) {




1,160,715✔






UNCOV

2061



    code = terrno;




×







2062



    TAOS_RETURN(code);




×







2063



  }










2064












2065



  int32_t ret = 0;




1,160,715✔





2066



  if ((ret = tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp)) < 0) return ret;




1,160,715✔





2067



  *pRspLen = rspLen;




1,160,715✔





2068



  *ppRsp = pRsp;




1,160,715✔





2069



  TAOS_RETURN(code);




1,160,715✔





2070



}










2071












2072



static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {




672,756✔





2073



  int32_t code = -1;




672,756✔





2074












2075



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-db");




672,756✔





2076



  if (pTrans == NULL) {




672,756✔






UNCOV

2077



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2078



    if (terrno != 0) code = terrno;




×








UNCOV

2079



    goto _OVER;




×







2080



  }










2081












2082



  mInfo("trans:%d start to drop db:%s", pTrans->id, pDb->name);




672,756✔





2083












2084



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




672,756✔





2085



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




672,756✔





2086












2087



  if (mndTopicExistsForDb(pMnode, pDb)) {




672,756✔





2088



    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;




362✔





2089



    goto _OVER;




362✔





2090



  }










2091












2092



  TAOS_CHECK_GOTO(mndSetDropDbPrepareLogs(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2093



  TAOS_CHECK_GOTO(mndSetDropDbCommitLogs(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2094



  TAOS_CHECK_GOTO(mndDropStreamByDb(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2095



#ifdef TD_ENTERPRISE










2096



  TAOS_CHECK_GOTO(mndDropViewByDb(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2097



#endif










2098



  TAOS_CHECK_GOTO(mndDropTSMAsByDb(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2099



  TAOS_CHECK_GOTO(mndDropRsmasByDb(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2100



  TAOS_CHECK_GOTO(mndDropIdxsByDb(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2101



  //TAOS_CHECK_GOTO(mndStreamSetStopStreamTasksActions(pMnode, pTrans, pDb->uid), NULL, _OVER);










2102



  TAOS_CHECK_GOTO(mndSetDropDbRedoActions(pMnode, pTrans, pDb), NULL, _OVER);




672,394✔





2103



  TAOS_CHECK_GOTO(mndPrincipalRemoveDb(pMnode, pTrans, pDb, NULL, NULL), NULL, _OVER);




672,394✔





2104












2105



  int32_t rspLen = 0;




672,394✔





2106



  void   *pRsp = NULL;




672,394✔





2107



  TAOS_CHECK_GOTO(mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false), NULL, _OVER);




672,394✔





2108



  mndTransSetRpcRsp(pTrans, pRsp, rspLen);




672,394✔





2109












2110



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




672,394✔





2111



  code = 0;




672,394✔





2112












2113



_OVER:




672,756✔





2114



  mndTransDrop(pTrans);




672,756✔





2115



  TAOS_RETURN(code);




672,756✔





2116



}










2117












2118



static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {




1,167,466✔





2119



  SMnode    *pMnode = pReq->info.node;




1,167,466✔





2120



  int32_t    code = -1;




1,167,466✔





2121



  SDbObj    *pDb = NULL;




1,167,466✔





2122



  SDropDbReq dropReq = {0};




1,167,466✔





2123



  int64_t    tss = taosGetTimestampMs();




1,167,466✔





2124












2125



  TAOS_CHECK_GOTO(tDeserializeSDropDbReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);




1,167,466✔





2126












2127



  mInfo("db:%s, start to drop", dropReq.db);




1,167,466✔





2128












2129



  pDb = mndAcquireDb(pMnode, dropReq.db);




1,167,466✔





2130



  if (pDb == NULL) {




1,167,466✔





2131



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




492,302✔





2132



    if (terrno != 0) code = terrno;




492,302✔





2133



    int32_t ret =










2134



        mndCheckDbPrivilegeByName(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_DROP_DB, dropReq.db, true);




492,302✔





2135



    if (ret != 0) {




492,302✔






UNCOV

2136



      code = ret;




×








UNCOV

2137



      goto _OVER;




×







2138



    }










2139



    if (dropReq.ignoreNotExists) {




492,302✔





2140



      code = mndBuildDropDbRsp(pDb, &pReq->info.rspLen, &pReq->info.rsp, true);




488,321✔





2141



    }










2142



    goto _OVER;




492,302✔





2143



  }










2144












2145



  if ((code = mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_DROP_DB, pDb))) {




675,164✔






UNCOV

2146



    goto _OVER;




×







2147



  }










2148












2149



  if(pDb->cfg.isMount) {




675,164✔





2150



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




556✔





2151



    goto _OVER;




556✔





2152



  }










2153












2154



  if(!pDb->cfg.allowDrop) {




674,608✔






UNCOV

2155



    code = TSDB_CODE_MND_DB_DROP_NOT_ALLOWED;




×







2156



    goto _OVER;




×







2157



  }










2158












2159



  SSdb *pSdb = pMnode->pSdb;




674,608✔





2160



  void *pIter = NULL;




674,608✔





2161












2162



  while (1) {




3,390,951✔





2163



    SVgObj *pVgroup = NULL;




4,065,559✔





2164



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




4,065,559✔





2165



    if (pIter == NULL) break;




4,065,559✔





2166












2167



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




3,391,653✔





2168



      bool isFound = false;




1,445,270✔





2169



      for (int32_t i = 0; i < pVgroup->replica; i++) {




2,958,760✔





2170



        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_OFFLINE) {




1,514,192✔





2171



          isFound = true;




702✔





2172



          break;




702✔





2173



        }










2174



      }










2175



      if (!isFound) {




1,445,270✔





2176



        sdbRelease(pSdb, pVgroup);




1,444,568✔





2177



        continue;




1,444,568✔





2178



      }










2179



      code = TSDB_CODE_MND_VGROUP_OFFLINE;




702✔





2180



      sdbCancelFetch(pSdb, pIter);




702✔





2181



      sdbRelease(pSdb, pVgroup);




702✔





2182



      goto _OVER;




702✔





2183



    }










2184












2185



    sdbRelease(pSdb, pVgroup);




1,946,383✔





2186



  }










2187












2188



  bool dbStream = false;




673,906✔





2189



  bool vtableStream = false;




673,906✔





2190



  mstCheckDbInUse(pMnode, dropReq.db, &dbStream, &vtableStream, true);




673,906✔





2191



  if (dbStream) {




673,906✔





2192



    code = TSDB_CODE_MND_STREAM_DB_IN_USE;




920✔





2193



    mError("db:%s used by streams, drop db not allowed", dropReq.db);




920✔





2194



    goto _OVER;




920✔





2195



  }










2196












2197



  if (vtableStream && !dropReq.force) {




672,986✔





2198



    code = TSDB_CODE_MND_STREAM_VTABLE_EXITS;




230✔





2199



    mError("db:%s, vtable stream exists, drop db not allowed", dropReq.db);




230✔





2200



    goto _OVER;




230✔





2201



  }










2202












2203



  code = mndDropDb(pMnode, pReq, pDb);




672,756✔





2204



  if (code == TSDB_CODE_SUCCESS) {




672,756✔





2205



    code = TSDB_CODE_ACTION_IN_PROGRESS;




672,394✔





2206



  }










2207












2208



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




672,756✔





2209



    SName name = {0};




672,756✔





2210



    if (tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB) < 0)




672,756✔






UNCOV

2211



      mError("db:%s, failed to parse db name", dropReq.db);




×







2212












2213



    int64_t tse = taosGetTimestampMs();




672,756✔





2214



    double  duration = (double)(tse - tss);




672,756✔





2215



    duration = duration / 1000;




672,756✔





2216



    auditRecord(pReq, pMnode->clusterId, "dropDB", name.dbname, "", dropReq.sql, dropReq.sqlLen, duration, 0);




672,756✔





2217



  }










2218












2219



_OVER:




1,165,658✔





2220



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




1,167,466✔





2221



    mError("db:%s, failed to drop since %s", dropReq.db, terrstr());




6,751✔





2222



  }










2223












2224



  mndReleaseDb(pMnode, pDb);




1,167,466✔





2225



  tFreeSDropDbReq(&dropReq);




1,167,466✔





2226



  TAOS_RETURN(code);




1,167,466✔





2227



}










2228












2229



static int32_t mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode) {




26,561,323✔





2230



  int32_t numOfTables = 0;




26,561,323✔





2231



  int32_t vindex = 0;




26,561,323✔





2232



  SSdb   *pSdb = pMnode->pSdb;




26,561,323✔





2233












2234



  void *pIter = NULL;




26,561,323✔





2235



  while (vindex < pDb->cfg.numOfVgroups) {




106,857,922✔





2236



    SVgObj *pVgroup = NULL;




80,296,570✔





2237



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




80,296,599✔





2238



    if (pIter == NULL) break;




80,296,599✔





2239












2240



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




80,296,599✔





2241



      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




53,300,115✔





2242



      vindex++;




53,299,957✔





2243



    }










2244












2245



    sdbRelease(pSdb, pVgroup);




80,296,441✔





2246



  }










2247












2248



  sdbCancelFetch(pSdb, pIter);




26,561,323✔





2249



  return numOfTables;




26,561,323✔





2250



}










2251












2252



void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {




26,997,845✔





2253



  int32_t vindex = 0;




26,997,845✔





2254



  SSdb   *pSdb = pMnode->pSdb;




26,997,845✔





2255












2256



  void *pIter = NULL;




26,997,845✔





2257



  while (1) {




57,673,821✔





2258



    SVgObj *pVgroup = NULL;




84,671,666✔





2259



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




84,671,305✔





2260



    if (pIter == NULL) break;




84,671,666✔





2261












2262



    if ((NULL == pDb || pVgroup->dbUid == pDb->uid) && !pVgroup->isTsma) {




78,507,386✔





2263



      SVgroupInfo vgInfo = {0};




62,211,316✔





2264



      vgInfo.vgId = pVgroup->vgId;




62,211,316✔





2265



      vgInfo.hashBegin = pVgroup->hashBegin;




62,211,316✔





2266



      vgInfo.hashEnd = pVgroup->hashEnd;




62,211,316✔





2267



      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




62,211,316✔





2268



      vgInfo.epSet.numOfEps = pVgroup->replica;




62,211,316✔





2269



      for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {




128,569,964✔





2270



        SVnodeGid *pVgid = &pVgroup->vnodeGid[gid];




66,358,648✔





2271



        SEp       *pEp = &vgInfo.epSet.eps[gid];




66,358,648✔





2272



        SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);




66,358,648✔





2273



        if (pDnode != NULL) {




66,358,648✔





2274



          (void)memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);




66,324,142✔





2275



          pEp->port = pDnode->port;




66,324,142✔





2276



        }










2277



        mndReleaseDnode(pMnode, pDnode);




66,358,648✔





2278



        if (pVgid->syncState == TAOS_SYNC_STATE_LEADER || pVgid->syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {




66,358,648✔





2279



          vgInfo.epSet.inUse = gid;




61,729,612✔





2280



        }










2281



      }










2282



      vindex++;




62,211,316✔





2283



      if (taosArrayPush(pVgList, &vgInfo) == NULL) {




62,211,316✔






UNCOV

2284



        mError("db:%s, failed to push vgInfo to array, vgId:%d, but continue next", pDb->name, vgInfo.vgId);




×







2285



      }










2286



    }










2287












2288



    sdbRelease(pSdb, pVgroup);




78,507,386✔





2289












2290



    if (pDb && (vindex >= pDb->cfg.numOfVgroups)) {




78,507,386✔





2291



      sdbCancelFetch(pSdb, pIter);




20,833,565✔





2292



      break;




20,833,565✔





2293



    }










2294



  }










2295



}




26,997,845✔





2296












2297



int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq) {




20,959,710✔





2298



  int32_t code = 0;




20,959,710✔





2299



  pRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));




20,959,710✔





2300



  if (pRsp->pVgroupInfos == NULL) {




20,959,710✔






UNCOV

2301



    code = terrno;




×








UNCOV

2302



    TAOS_RETURN(code);




×







2303



  }










2304












2305



  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




20,959,710✔





2306












2307



  if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable ||




20,959,710✔





2308



      pReq->stateTs < pDb->stateTs) {




1,164,560✔





2309



    mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);




19,936,544✔





2310



  }










2311












2312



  (void)memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);




20,959,710✔





2313



  pRsp->uid = pDb->uid;




20,959,710✔





2314



  pRsp->vgVersion = pDb->vgVersion;




20,959,710✔





2315



  pRsp->stateTs = pDb->stateTs;




20,959,710✔





2316



  pRsp->vgNum = taosArrayGetSize(pRsp->pVgroupInfos);




20,959,708✔





2317



  pRsp->hashMethod = pDb->cfg.hashMethod;




20,959,708✔





2318



  pRsp->hashPrefix = pDb->cfg.hashPrefix;




20,959,708✔





2319



  pRsp->hashSuffix = pDb->cfg.hashSuffix;




20,959,708✔





2320



  pRsp->flags = pDb->cfg.flags;




20,959,708✔





2321



  TAOS_RETURN(code);




20,959,708✔





2322



}










2323












2324



static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {




26,936,898✔





2325



  SMnode   *pMnode = pReq->info.node;




26,936,898✔





2326



  int32_t   code = -1;




26,936,898✔





2327



  SDbObj   *pDb = NULL;




26,936,898✔





2328



  SUseDbReq usedbReq = {0};




26,936,898✔





2329



  SUseDbRsp usedbRsp = {0};




26,936,898✔





2330












2331



  TAOS_CHECK_GOTO(tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq), NULL, _OVER);




26,936,898✔





2332












2333



  char *p = strchr(usedbReq.db, '.');




26,936,900✔





2334



  if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {




26,936,900✔





2335



    (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);




5,869,403✔





2336



    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




5,869,403✔





2337



    if (usedbReq.vgVersion < vgVersion) {




5,869,403✔





2338



      usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));




5,861,897✔





2339



      if (usedbRsp.pVgroupInfos == NULL) goto _OVER;




5,861,897✔





2340












2341



      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);




5,861,897✔





2342



      usedbRsp.vgVersion = vgVersion++;




5,861,897✔





2343



    } else {










2344



      usedbRsp.vgVersion = usedbReq.vgVersion;




7,506✔





2345



    }










2346



    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);




5,869,403✔





2347



    code = 0;




5,869,403✔





2348



  } else {










2349



    pDb = mndAcquireDb(pMnode, usedbReq.db);




21,067,495✔





2350



    if (pDb == NULL) {




21,067,495✔





2351



      (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);




100,893✔





2352



      usedbRsp.uid = usedbReq.dbId;




100,893✔





2353



      usedbRsp.vgVersion = usedbReq.vgVersion;




100,893✔





2354



      usedbRsp.errCode = terrno;




100,893✔





2355












2356



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




100,893✔





2357



      if (terrno != 0) code = terrno;




100,893✔





2358



      goto _OVER;




100,893✔





2359



    } else {










2360



      TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_USE_DB, pDb), NULL, _OVER);




20,966,602✔





2361












2362



      TAOS_CHECK_GOTO(mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq), NULL, _OVER);




20,959,710✔





2363












2364



      mDebug("db:%s, process usedb req vgVersion:%d stateTs:%" PRId64 ", rsp vgVersion:%d stateTs:%" PRId64,




20,959,708✔





2365



             usedbReq.db, usedbReq.vgVersion, usedbReq.stateTs, usedbRsp.vgVersion, usedbRsp.stateTs);










2366



      code = 0;




20,959,710✔





2367



    }










2368



  }










2369












2370



  int32_t contLen = tSerializeSUseDbRsp(NULL, 0, &usedbRsp);




26,829,113✔





2371



  void   *pRsp = rpcMallocCont(contLen);




26,829,113✔





2372



  if (pRsp == NULL) {




26,829,111✔






UNCOV

2373



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2374



    code = -1;




×








UNCOV

2375



    goto _OVER;




×







2376



  }










2377












2378



  int32_t ret = 0;




26,829,111✔





2379



  if ((ret = tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp)) < 0) {




26,829,111✔






UNCOV

2380



    code = ret;




×








UNCOV

2381



    goto _OVER;




×







2382



  }










2383












2384



  pReq->info.rsp = pRsp;




26,829,113✔





2385



  pReq->info.rspLen = contLen;




26,829,113✔





2386












2387



_OVER:




26,936,898✔





2388



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




26,936,898✔





2389



    mError("db:%s, failed to process use db req since %s", usedbReq.db, tstrerror(code));




107,787✔





2390



  }










2391












2392



  mndReleaseDb(pMnode, pDb);




26,936,898✔





2393



  tFreeSUsedbRsp(&usedbRsp);




26,936,900✔





2394












2395



  TAOS_RETURN(code);




26,936,900✔





2396



}










2397












2398



int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {




7,331,915✔





2399



  int32_t       code = 0;




7,331,915✔





2400



  SDbHbBatchRsp batchRsp = {0};




7,331,915✔





2401



  batchRsp.pArray = taosArrayInit(numOfDbs, sizeof(SDbHbRsp));




7,331,915✔





2402



  if (batchRsp.pArray == NULL) {




7,331,915✔






UNCOV

2403



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2404



    TAOS_RETURN(code);




×







2405



  }










2406












2407



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




16,035,145✔





2408



    SDbCacheInfo *pDbCacheInfo = &pDbs[i];




8,703,230✔





2409



    pDbCacheInfo->dbId = be64toh(pDbCacheInfo->dbId);




8,703,230✔





2410



    pDbCacheInfo->vgVersion = htonl(pDbCacheInfo->vgVersion);




8,703,230✔





2411



    pDbCacheInfo->cfgVersion = htonl(pDbCacheInfo->cfgVersion);




8,703,230✔





2412



    pDbCacheInfo->numOfTable = htonl(pDbCacheInfo->numOfTable);




8,702,642✔





2413



    pDbCacheInfo->stateTs = be64toh(pDbCacheInfo->stateTs);




8,703,230✔





2414



    pDbCacheInfo->tsmaVersion = htonl(pDbCacheInfo->tsmaVersion);




8,702,642✔





2415












2416



    SDbHbRsp rsp = {0};




8,702,642✔





2417



    (void)memcpy(rsp.db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);




8,703,230✔





2418



    rsp.dbId = pDbCacheInfo->dbId;




8,703,230✔





2419












2420



    if ((0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||




8,703,230✔





2421



         (0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {




8,195,703✔





2422



      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




3,060,282✔





2423



      if (pDbCacheInfo->vgVersion >= vgVersion) {




3,060,870✔





2424



        continue;




2,758,959✔





2425



      }










2426












2427



      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));




302,383✔





2428



      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);




302,383✔





2429



      rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));




302,383✔





2430












2431



      mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);




302,383✔





2432



      rsp.useDbRsp->vgVersion = vgVersion++;




302,383✔





2433












2434



      rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);




302,383✔





2435












2436



      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {




604,766✔





2437



        if (terrno != 0) code = terrno;




×







2438



        return code;




×







2439



      }










2440












2441



      continue;




302,383✔





2442



    }










2443












2444



    SDbObj *pDb = mndAcquireDb(pMnode, pDbCacheInfo->dbFName);




5,642,360✔





2445



    if (pDb == NULL) {




5,642,360✔





2446



      mTrace("db:%s, no exist", pDbCacheInfo->dbFName);




40,747✔





2447



      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));




40,747✔





2448



      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);




40,747✔





2449



      rsp.useDbRsp->uid = pDbCacheInfo->dbId;




40,747✔





2450



      rsp.useDbRsp->vgVersion = -1;




40,747✔





2451



      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {




81,494✔






UNCOV

2452



        if (terrno != 0) code = terrno;




×








UNCOV

2453



        return code;




×







2454



      }










2455



      continue;




40,747✔





2456



    }










2457












2458



    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




5,601,613✔





2459












2460



    if (pDbCacheInfo->vgVersion >= pDb->vgVersion && pDbCacheInfo->cfgVersion >= pDb->cfgVersion &&




5,601,613✔





2461



        numOfTable == pDbCacheInfo->numOfTable && pDbCacheInfo->stateTs == pDb->stateTs &&




5,534,075✔





2462



        pDbCacheInfo->tsmaVersion >= pDb->tsmaVersion) {




4,687,415✔





2463



      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64




4,329,660✔





2464



             " numOfTables:%d, not changed vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",










2465



             pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs,










2466



             pDbCacheInfo->numOfTable, pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);










2467



      mndReleaseDb(pMnode, pDb);




4,329,660✔





2468



      continue;




4,329,660✔





2469



    } else {










2470



      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64




1,271,953✔





2471



             " numOfTables:%d, changed to vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",










2472



             pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs,










2473



             pDbCacheInfo->numOfTable, pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);










2474



    }










2475












2476



    if (pDbCacheInfo->cfgVersion < pDb->cfgVersion) {




1,271,953✔





2477



      rsp.cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp));




46,584✔





2478



      char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




46,584✔





2479



      mndGetEncryptOsslAlgrNameById(pMnode, pDb->cfg.encryptAlgorithm, algrId);




46,584✔





2480



      mndDumpDbCfgInfo(rsp.cfgRsp, pDb, algrId);




46,584✔





2481



    }










2482












2483



    if (pDbCacheInfo->tsmaVersion != pDb->tsmaVersion) {




1,271,953✔





2484



      rsp.pTsmaRsp = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp));




817,507✔





2485



      if (rsp.pTsmaRsp) rsp.pTsmaRsp->pTsmas = taosArrayInit(4, POINTER_BYTES);




817,507✔





2486



      if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {




817,507✔





2487



        bool    exist = false;




817,507✔





2488



        int32_t code = mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);




817,507✔





2489



        if (TSDB_CODE_SUCCESS != code) {




817,507✔





2490



          mndReleaseDb(pMnode, pDb);




2,512✔





2491



          if (code != TSDB_CODE_NEED_RETRY) {




2,512✔





2492



            mError("db:%s, failed to get db tsmas", pDb->name);




2,512✔





2493



          } else {











UNCOV

2494



            mWarn("db:%s, need retry to get db tsmas", pDb->name);




×







2495



          }










2496



          taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);




2,512✔





2497



          taosMemoryFreeClear(rsp.pTsmaRsp);




2,512✔





2498



          continue;




2,512✔





2499



        }










2500



        rsp.dbTsmaVersion = pDb->tsmaVersion;




814,995✔





2501



        mDebug("update tsma version to %d, got tsma num: %ld", pDb->tsmaVersion, rsp.pTsmaRsp->pTsmas->size);




814,995✔





2502



      }










2503



    }










2504












2505



    if (pDbCacheInfo->vgVersion < pDb->vgVersion || numOfTable != pDbCacheInfo->numOfTable ||




1,269,441✔





2506



        pDbCacheInfo->stateTs != pDb->stateTs) {




1,230,655✔





2507



      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));




897,021✔





2508



      rsp.useDbRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));




897,021✔





2509



      if (rsp.useDbRsp->pVgroupInfos == NULL) {




897,021✔






UNCOV

2510



        mndReleaseDb(pMnode, pDb);




×








UNCOV

2511



        mError("db:%s, failed to malloc usedb response", pDb->name);




×








UNCOV

2512



        taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);




×








UNCOV

2513



        taosMemoryFreeClear(rsp.pTsmaRsp);




×








UNCOV

2514



        continue;




×







2515



      }










2516












2517



      mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);




897,021✔





2518



      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);




897,021✔





2519



      rsp.useDbRsp->uid = pDb->uid;




897,021✔





2520



      rsp.useDbRsp->vgVersion = pDb->vgVersion;




897,021✔





2521



      rsp.useDbRsp->stateTs = pDb->stateTs;




897,021✔





2522



      rsp.useDbRsp->vgNum = (int32_t)taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);




897,021✔





2523



      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;




897,021✔





2524



      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;




897,021✔





2525



      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;




897,021✔





2526



      rsp.useDbRsp->flags = pDb->cfg.flags;




897,021✔





2527



    }










2528












2529



    if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {




2,538,882✔






UNCOV

2530



      mndReleaseDb(pMnode, pDb);




×








UNCOV

2531



      if (terrno != 0) code = terrno;




×








UNCOV

2532



      return code;




×







2533



    }










2534



    mndReleaseDb(pMnode, pDb);




1,269,441✔





2535



  }










2536












2537



  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);




7,331,915✔





2538



  void   *pRsp = taosMemoryMalloc(rspLen);




7,331,915✔





2539



  if (pRsp == NULL) {




7,331,915✔






UNCOV

2540



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2541



    tFreeSDbHbBatchRsp(&batchRsp);




×








UNCOV

2542



    return -1;




×







2543



  }










2544



  int32_t ret = 0;




7,331,915✔





2545



  if ((ret = tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp)) < 0) return ret;




7,331,915✔





2546












2547



  *ppRsp = pRsp;




7,331,915✔





2548



  *pRspLen = rspLen;




7,331,915✔





2549












2550



  tFreeSDbHbBatchRsp(&batchRsp);




7,331,915✔





2551



  TAOS_RETURN(code);




7,331,915✔





2552



}










2553












2554



static int32_t mndSetTrimDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t startTs, STimeWindow tw,




25,326✔





2555



                                       SArray *vgroupIds, ETsdbOpType type, ETriggerType triggerType,










2556



                                       STrimDbRsp *pRsp) {










2557



  int32_t code = 0, lino = 0;




25,326✔





2558



  SSdb   *pSdb = pMnode->pSdb;




25,326✔





2559



  void   *pIter = NULL;




25,326✔





2560












2561



  SRetentionObj obj = {.optrType = type, .triggerType = triggerType};  // reuse SCompactObj struct




25,326✔





2562



  TAOS_CHECK_EXIT(mndAddRetentionToTrans(pMnode, pTrans, &obj, pDb, pRsp));




25,326✔





2563












2564



  int32_t j = 0;




25,326✔





2565



  int32_t numOfVgroups = taosArrayGetSize(vgroupIds);




25,326✔





2566



  if (numOfVgroups > 0) {




25,326✔





2567



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




8,916✔





2568



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




6,687✔





2569



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




6,687✔





2570












2571



      if (pVgroup == NULL) {




6,687✔





2572



        mError("db:%s, vgroup:%" PRId64 " not exist", pDb->name, vgId);




2,229✔





2573



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




2,229✔





2574



      } else if (pVgroup->dbUid != pDb->uid) {




4,458✔






UNCOV

2575



        mError("db:%s, vgroup:%" PRId64 " not belong to db:%s", pDb->name, vgId, pDb->name);




×








UNCOV

2576



        sdbRelease(pSdb, pVgroup);




×








UNCOV

2577



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




×







2578



      }










2579



      sdbRelease(pSdb, pVgroup);




4,458✔





2580



    }










2581












2582



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




6,687✔





2583



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




4,458✔





2584



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




4,458✔





2585












2586



      if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




4,458✔






UNCOV

2587



        sdbRelease(pSdb, pVgroup);




×








UNCOV

2588



        TAOS_RETURN(code);




×







2589



      }










2590












2591



      for (int32_t i = 0; i < pVgroup->replica; i++) {




8,916✔





2592



        SVnodeGid *gid = &pVgroup->vnodeGid[i];




4,458✔





2593



        if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




4,458✔





2594



          sdbRelease(pSdb, pVgroup);




×







2595



          TAOS_RETURN(code);




×







2596



        }










2597



        j++;




4,458✔





2598



      }










2599



      sdbRelease(pSdb, pVgroup);




4,458✔





2600



    }










2601



  } else {










2602



    while (1) {




85,442✔





2603



      SVgObj *pVgroup = NULL;




106,310✔





2604



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




106,310✔





2605



      if (pIter == NULL) break;




106,310✔





2606












2607



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




85,442✔





2608



        if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




49,916✔






UNCOV

2609



          sdbCancelFetch(pSdb, pIter);




×








UNCOV

2610



          sdbRelease(pSdb, pVgroup);




×








UNCOV

2611



          TAOS_RETURN(code);




×







2612



        }










2613












2614



        for (int32_t i = 0; i < pVgroup->replica; i++) {




108,324✔





2615



          SVnodeGid *gid = &pVgroup->vnodeGid[i];




58,408✔





2616



          if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




58,408✔






UNCOV

2617



            sdbCancelFetch(pSdb, pIter);




×








UNCOV

2618



            sdbRelease(pSdb, pVgroup);




×








UNCOV

2619



            TAOS_RETURN(code);




×







2620



          }










2621



          j++;




58,408✔





2622



        }










2623



      }










2624












2625



      sdbRelease(pSdb, pVgroup);




85,442✔





2626



    }










2627



  }










2628



_exit:




25,326✔





2629



  TAOS_RETURN(code);




25,326✔





2630



}










2631












2632



static int32_t mndBuildTrimDbRsp(STrimDbRsp *rsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




23,097✔





2633



  int32_t code = 0;




23,097✔





2634



  int32_t rspLen = tSerializeSCompactDbRsp(NULL, 0, (SCompactDbRsp *)rsp);




23,097✔





2635



  void   *pRsp = NULL;




23,097✔





2636



  if (useRpcMalloc) {




23,097✔






UNCOV

2637



    pRsp = rpcMallocCont(rspLen);




×







2638



  } else {










2639



    pRsp = taosMemoryMalloc(rspLen);




23,097✔





2640



  }










2641












2642



  if (pRsp == NULL) {




23,097✔






UNCOV

2643



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2644



    TAOS_RETURN(code);




×







2645



  }










2646












2647



  (void)tSerializeSCompactDbRsp(pRsp, rspLen, (SCompactDbRsp *)rsp);




23,097✔





2648



  *pRspLen = rspLen;




23,097✔





2649



  *ppRsp = pRsp;




23,097✔





2650



  TAOS_RETURN(code);




23,097✔





2651



}










2652












2653



int32_t mndTrimDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, STimeWindow tw, SArray *vgroupIds,




29,951✔





2654



                         ETsdbOpType type, ETriggerType triggerType) {










2655



  SSdb      *pSdb = pMnode->pSdb;




29,951✔





2656



  SVgObj    *pVgroup = NULL;




29,951✔





2657



  void      *pIter = NULL;




29,951✔





2658



  int32_t    code = 0, lino = 0;




29,951✔





2659



  STrimDbRsp rsp = {0};




29,951✔





2660



  bool       isExist = false;




29,951✔





2661












2662



  while (1) {




8,773✔





2663



    SRetentionObj *pObj = NULL;




38,724✔





2664



    pIter = sdbFetch(pMnode->pSdb, SDB_RETENTION, pIter, (void **)&pObj);




38,724✔





2665



    if (pIter == NULL) break;




38,724✔





2666












2667



    if (strcmp(pObj->dbname, pDb->name) == 0) {




8,773✔





2668



      isExist = true;




4,458✔





2669



    }










2670



    sdbRelease(pMnode->pSdb, pObj);




8,773✔





2671



  }










2672



  if (isExist) {




29,951✔





2673



    mInfo("trim db:%s already exist", pDb->name);




4,458✔





2674



    TAOS_RETURN(TSDB_CODE_MND_TRIM_ALREADY_EXIST);




4,458✔





2675



  }










2676












2677



  int64_t startTs = taosGetTimestampMs();




25,493✔





2678



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "trim-db");




25,493✔





2679



  if (pTrans == NULL) goto _exit;




25,493✔





2680



  mInfo("trans:%d, used to trim db:%s", pTrans->id, pDb->name);




25,493✔





2681



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




25,493✔





2682



  TAOS_CHECK_EXIT(mndTrancCheckConflict(pMnode, pTrans));




25,493✔





2683



  TAOS_CHECK_EXIT(mndSetTrimDbRedoActions(pMnode, pTrans, pDb, startTs, tw, vgroupIds, type, triggerType, &rsp));




25,326✔





2684



  if (pReq) {




23,097✔





2685



    int32_t rspLen = 0;




23,097✔





2686



    void   *pRsp = NULL;




23,097✔





2687



    rsp.bAccepted = true;




23,097✔





2688



    TAOS_CHECK_EXIT(mndBuildTrimDbRsp(&rsp, &rspLen, &pRsp, false));




23,097✔





2689



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




23,097✔





2690



  }










2691



  TAOS_CHECK_EXIT(mndTransPrepare(pMnode, pTrans));




23,097✔





2692



_exit:




25,493✔





2693



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




25,493✔





2694



    mError("db:%s, failed at line %d to trim db since %s", pDb->name, lino, tstrerror(code));




2,396✔





2695



  }










2696



  mndTransDrop(pTrans);




25,493✔





2697



  TAOS_RETURN(code);




25,493✔





2698



}










2699












2700



#ifdef TD_ENTERPRISE










2701



static int32_t mndCheckRsmaInDb(SMnode *pMnode, SDbObj *pDb) {




14,117✔





2702



  int32_t   code = 0;




14,117✔





2703



  void     *pIter = NULL;




14,117✔





2704



  SRsmaObj *pRsma = NULL;




14,117✔





2705



  while ((pIter = sdbFetch(pMnode->pSdb, SDB_RSMA, pIter, (void **)&pRsma))) {




14,117✔





2706



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




14,117✔





2707



      sdbRelease(pMnode->pSdb, pRsma);




14,117✔





2708



      sdbCancelFetch(pMnode->pSdb, pIter);




14,117✔





2709



      TAOS_RETURN(code);




14,117✔





2710



    }











UNCOV

2711



    sdbRelease(pMnode->pSdb, pRsma);




×







2712



  }











UNCOV

2713



  TAOS_RETURN(TSDB_CODE_RSMA_NOT_EXIST);




×







2714



}










2715



#endif










2716












2717



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {




22,523✔





2718



  SMnode    *pMnode = pReq->info.node;




22,523✔





2719



  int32_t    code = 0, lino = 0;




22,523✔





2720



  SDbObj    *pDb = NULL;




22,523✔





2721



  STrimDbReq trimReq = {0};




22,523✔





2722



  int64_t    tss = taosGetTimestampMs();




22,523✔





2723












2724



  TAOS_CHECK_EXIT(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq));




22,523✔





2725












2726



  mInfo("db:%s, start to trim, optr:%u, tw:%" PRId64 ",%" PRId64, trimReq.db, trimReq.optrType, trimReq.tw.skey,




22,523✔





2727



        trimReq.tw.ekey);










2728












2729



  pDb = mndAcquireDb(pMnode, trimReq.db);




22,523✔





2730



  if (pDb == NULL) {




22,523✔






UNCOV

2731



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2732



    if (terrno != 0) code = terrno;




×








UNCOV

2733



    TAOS_CHECK_EXIT(code);




×







2734



  }










2735












2736



  TAOS_CHECK_EXIT(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb));




22,523✔





2737












2738



  if (pDb->cfg.isMount) {




22,523✔





2739



    TAOS_CHECK_EXIT(TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT);




×







2740



  }










2741












2742



#ifdef TD_ENTERPRISE










2743



  if (trimReq.optrType == TSDB_OPTR_ROLLUP) {




22,523✔





2744



    TAOS_CHECK_EXIT(mndCheckRsmaInDb(pMnode, pDb));




14,117✔





2745



  }










2746



#endif










2747












2748



  TAOS_CHECK_EXIT(mndTrimDb(pMnode, pReq, pDb, trimReq.tw, trimReq.vgroupIds, trimReq.optrType, trimReq.triggerType));




22,523✔





2749



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




15,836✔





2750












2751



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




15,836✔





2752



    SName name = {0};




15,836✔





2753



    if (tNameFromString(&name, trimReq.db, T_NAME_ACCT | T_NAME_DB) < 0) {




15,836✔






UNCOV

2754



      mWarn("db:%s, failed at line %d to parse db name", trimReq.db, __LINE__);




×







2755



    }










2756












2757



    char optrType[16] = {0};




15,836✔





2758



    (void)snprintf(optrType, sizeof(optrType), "%u", trimReq.optrType);




15,836✔





2759



    int64_t tse = taosGetTimestampMs();




15,836✔





2760



    double  duration = (double)(tse - tss);




15,836✔





2761



    duration = duration / 1000;




15,836✔





2762



    auditRecord(pReq, pMnode->clusterId, "trimDB", name.dbname, optrType, trimReq.sql, trimReq.sqlLen, duration, 0);




15,836✔





2763



  }










2764












2765



_exit:




22,523✔





2766



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




22,523✔





2767



    mError("db:%s, failed at line %d to process trim db req since %s, optr:%u", trimReq.db, lino, tstrerror(code),




6,687✔





2768



           trimReq.optrType);










2769



  }










2770












2771



  mndReleaseDb(pMnode, pDb);




22,523✔





2772



  tFreeSTrimDbReq(&trimReq);




22,523✔





2773



  TAOS_RETURN(code);




22,523✔





2774



}










2775












2776



static int32_t mndBuildSsMigrateDbRsp(SSsMigrateDbRsp *pSsMigrateRsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




2,229✔





2777



  int32_t code = 0;




2,229✔





2778



  int32_t rspLen = tSerializeSSsMigrateDbRsp(NULL, 0, pSsMigrateRsp);




2,229✔





2779



  void   *pRsp = NULL;




2,229✔





2780



  if (useRpcMalloc) {




2,229✔






UNCOV

2781



    pRsp = rpcMallocCont(rspLen);




×







2782



  } else {










2783



    pRsp = taosMemoryMalloc(rspLen);




2,229✔





2784



  }










2785












2786



  if (pRsp == NULL) {




2,229✔






UNCOV

2787



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2788



    TAOS_RETURN(code);




×







2789



  }










2790












2791



  (void)tSerializeSSsMigrateDbRsp(pRsp, rspLen, pSsMigrateRsp);




2,229✔





2792



  *pRspLen = rspLen;




2,229✔





2793



  *ppRsp = pRsp;




2,229✔





2794



  TAOS_RETURN(code);




2,229✔





2795



}










2796












2797



static int32_t mndTrimDbWal(SMnode *pMnode, SDbObj *pDb) {




1,064✔





2798



  SSdb   *pSdb = pMnode->pSdb;




1,064✔





2799



  SVgObj *pVgroup = NULL;




1,064✔





2800



  void   *pIter = NULL;




1,064✔





2801



  int32_t code = 0;




1,064✔





2802












2803



  // Iterate through all vgroups in this database










2804



  while (1) {




2,128✔





2805



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




3,192✔





2806



    if (pIter == NULL) break;




3,192✔





2807












2808



    // Check if this vgroup belongs to the database










2809



    if (pVgroup->dbUid != pDb->uid) {




2,128✔






UNCOV

2810



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2811



      continue;




×







2812



    }










2813












2814



    // Prepare message to send to vnode










2815



    int32_t   contLen = sizeof(SMsgHead);




2,128✔





2816



    SMsgHead *pHead = rpcMallocCont(contLen);




2,128✔





2817



    if (pHead == NULL) {




2,128✔






UNCOV

2818



      sdbCancelFetch(pSdb, pVgroup);




×








UNCOV

2819



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2820



      code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2821



      break;




×







2822



    }










2823



    pHead->contLen = htonl(contLen);




2,128✔





2824



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




2,128✔





2825












2826



    // Send TRIM WAL request to vnode










2827



    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM_WAL, .pCont = pHead, .contLen = contLen};




2,128✔





2828



    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);




2,128✔





2829



    code = tmsgSendReq(&epSet, &rpcMsg);




2,128✔





2830



    if (code != 0) {




2,128✔






UNCOV

2831



      mError("vgId:%d, failed to send vnode-trim-wal request since 0x%x", pVgroup->vgId, code);




×







2832



    } else {










2833



      mInfo("vgId:%d, send vnode-trim-wal request to vnode", pVgroup->vgId);




2,128✔





2834



    }










2835



    sdbRelease(pSdb, pVgroup);




2,128✔





2836



  }










2837












2838



  return code;




1,064✔





2839



}










2840












2841



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq) {




1,064✔





2842



  SMnode    *pMnode = pReq->info.node;




1,064✔





2843



  int32_t    code = -1;




1,064✔





2844



  SDbObj    *pDb = NULL;




1,064✔





2845



  STrimDbReq trimReq = {0};




1,064✔





2846












2847



  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);




1,064✔





2848












2849



  mInfo("db:%s, start to trim WAL", trimReq.db);




1,064✔





2850












2851



  pDb = mndAcquireDb(pMnode, trimReq.db);




1,064✔





2852



  if (pDb == NULL) {




1,064✔






UNCOV

2853



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2854



    if (terrno != 0) code = terrno;




×








UNCOV

2855



    goto _OVER;




×







2856



  }










2857












2858



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb), NULL, _OVER);




1,064✔





2859












2860



  code = mndTrimDbWal(pMnode, pDb);




1,064✔





2861












2862



_OVER:




1,064✔





2863



  if (code != 0) {




1,064✔






UNCOV

2864



    mError("db:%s, failed to process trim db wal req since %s", trimReq.db, terrstr());




×







2865



  }










2866












2867



  mndReleaseDb(pMnode, pDb);




1,064✔





2868



  TAOS_RETURN(code);




1,064✔





2869



}










2870












2871



int32_t mndSsMigrateDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {




2,229✔





2872



  int32_t       code = 0;




2,229✔





2873



  SSsMigrateDbRsp ssMigrateRsp = {0};




2,229✔





2874












2875



  bool  isExist = false;




2,229✔





2876



  void *pIter = NULL;




2,229✔





2877



  while (1) {




×







2878



    SSsMigrateObj *pSsMigrate = NULL;




2,229✔





2879



    pIter = sdbFetch(pMnode->pSdb, SDB_SSMIGRATE, pIter, (void **)&pSsMigrate);




2,229✔





2880



    if (pIter == NULL) break;




2,229✔





2881












2882



    if (strcmp(pSsMigrate->dbname, pDb->name) == 0) {




×







2883



      isExist = true;




×







2884



    }











UNCOV

2885



    sdbRelease(pMnode->pSdb, pSsMigrate);




×







2886



  }










2887



  if (isExist) {




2,229✔






UNCOV

2888



    mInfo("ssmigrate db:%s already exist", pDb->name);




×







2889













UNCOV

2890



    if (pReq) {




×







2891



      int32_t rspLen = 0;




×







2892



      void   *pRsp = NULL;




×








UNCOV

2893



      ssMigrateRsp.ssMigrateId = 0;




×








UNCOV

2894



      ssMigrateRsp.bAccepted = false;




×








UNCOV

2895



      TAOS_CHECK_RETURN(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, true));




×







2896













UNCOV

2897



      pReq->info.rsp = pRsp;




×








UNCOV

2898



      pReq->info.rspLen = rspLen;




×







2899



    }










2900













UNCOV

2901



    return TSDB_CODE_MND_SSMIGRATE_ALREADY_EXIST;




×







2902



  }










2903












2904



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "ssmigrate-db");




2,229✔





2905



  if (pTrans == NULL) {




2,229✔






UNCOV

2906



    mError("failed to create ssmigrate-db trans since %s", terrstr());




×








UNCOV

2907



    goto _OVER;




×







2908



  }










2909












2910



  mInfo("trans:%d, used to ssmigrate db:%s", pTrans->id, pDb->name);




2,229✔





2911



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




2,229✔





2912



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




2,229✔





2913












2914



  SSsMigrateObj ssMigrate = { .startTime = taosGetTimestampMs() };




2,229✔





2915



  TAOS_CHECK_GOTO(mndAddSsMigrateToTran(pMnode, pTrans, &ssMigrate, pDb), NULL, _OVER);




2,229✔





2916












2917



  if (pReq) {




2,229✔





2918



    int32_t rspLen = 0;




2,229✔





2919



    void   *pRsp = NULL;




2,229✔





2920



    ssMigrateRsp.ssMigrateId = ssMigrate.id;




2,229✔





2921



    ssMigrateRsp.bAccepted = true;




2,229✔





2922



    TAOS_CHECK_GOTO(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, false), NULL, _OVER);




2,229✔





2923



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




2,229✔





2924



  }










2925












2926



  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;




2,229✔





2927



  code = 0;




2,229✔





2928












2929



_OVER:




2,229✔





2930



  mndTransDrop(pTrans);




2,229✔





2931



  TAOS_RETURN(code);




2,229✔





2932



}










2933












2934












2935



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq) {




2,625✔





2936



  SMnode         *pMnode = pReq->info.node;




2,625✔





2937



  int32_t         code = -1;




2,625✔





2938



  SDbObj         *pDb = NULL;




2,625✔





2939



  SSsMigrateDbReq ssMigrateReq = {0};




2,625✔





2940












2941



  if (!tsSsEnabled) {




2,625✔





2942



    code = TSDB_CODE_OPS_NOT_SUPPORT;




396✔





2943



    goto _OVER;




396✔





2944



  }










2945












2946



  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_SHARED_STORAGE), NULL, _OVER);




2,229✔





2947



  TAOS_CHECK_GOTO(tDeserializeSSsMigrateDbReq(pReq->pCont, pReq->contLen, &ssMigrateReq), NULL, _OVER);




2,229✔





2948












2949



  mInfo("db:%s, start to ssmigrate", ssMigrateReq.db);




2,229✔





2950












2951



  pDb = mndAcquireDb(pMnode, ssMigrateReq.db);




2,229✔





2952



  if (pDb == NULL) {




2,229✔






UNCOV

2953



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2954



    if (terrno != 0) code = terrno;




×








UNCOV

2955



    goto _OVER;




×







2956



  }










2957












2958



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SSMIGRATE_DB, pDb), NULL, _OVER);




2,229✔





2959












2960



  if(pDb->cfg.isMount) {




2,229✔






UNCOV

2961



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×








UNCOV

2962



    goto _OVER;




×







2963



  }










2964












2965



  code = mndSsMigrateDb(pMnode, pReq, pDb);




2,229✔





2966












2967



_OVER:




2,625✔





2968



  if (code != 0) {




2,625✔





2969



    mError("db:%s, failed to process ssmigrate db req since %s", ssMigrateReq.db, tstrerror(code));




396✔





2970



  }










2971












2972



  mndReleaseDb(pMnode, pDb);




2,625✔





2973



  TAOS_RETURN(code);




2,625✔





2974



}










2975












2976



const char *mndGetDbStr(const char *src) {




19,830,504✔





2977



  char *pos = strstr(src, TS_PATH_DELIMITER);




19,830,504✔





2978



  if (pos != NULL) ++pos;




19,830,504✔





2979



  if (pos == NULL) return src;




19,830,504✔





2980



  return pos;




18,489,911✔





2981



}










2982












2983



const char *mndGetStableStr(const char *src) {




16,603,563✔





2984



  char *pos = strstr(src, TS_PATH_DELIMITER);




16,603,563✔





2985



  if (pos != NULL) ++pos;




16,603,563✔





2986



  if (pos == NULL) return src;




16,603,563✔





2987



  return mndGetDbStr(pos);




16,603,563✔





2988



}










2989












2990



static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {




×







2991



  int64_t v = 0;




×







2992



  switch (unit) {




×







2993



    case 's':




×







2994



      v = val / 1000;




×








UNCOV

2995



      break;




×








UNCOV

2996



    case 'm':




×







2997



      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];




×








UNCOV

2998



      break;




×








UNCOV

2999



    case 'h':




×








UNCOV

3000



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);




×








UNCOV

3001



      break;




×








UNCOV

3002



    case 'd':




×








UNCOV

3003



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);




×








UNCOV

3004



      break;




×








UNCOV

3005



    case 'w':




×







3006



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);




×







3007



      break;




×








UNCOV

3008



    default:




×







3009



      break;




×







3010



  }










3011












3012



  return v;




×







3013



}










3014












3015



static char *buildRetension(SArray *pRetension) {




567,169✔





3016



  size_t size = taosArrayGetSize(pRetension);




567,169✔





3017



  if (size == 0) {




567,169✔





3018



    return NULL;




567,169✔





3019



  }










3020












3021



  char       *p1 = taosMemoryCalloc(1, 100);




×








UNCOV

3022



  SRetention *p = taosArrayGet(pRetension, 0);




×







3023












3024



  int32_t len = 2;




×







3025












3026



  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×








UNCOV

3027



  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3028



  len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3029












3030



  if (size > 1) {




×








UNCOV

3031



    len += snprintf(p1 + len, 100 - len, ",");




×








UNCOV

3032



    p = taosArrayGet(pRetension, 1);




×







3033












3034



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×








UNCOV

3035



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×








UNCOV

3036



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3037



  }










3038













UNCOV

3039



  if (size > 2) {




×








UNCOV

3040



    len += snprintf(p1 + len, 100 - len, ",");




×








UNCOV

3041



    p = taosArrayGet(pRetension, 2);




×







3042













UNCOV

3043



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×








UNCOV

3044



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×








UNCOV

3045



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3046



  }










3047












3048



  varDataSetLen(p1, len);




×








UNCOV

3049



  return p1;




×







3050



}










3051












3052



static const char *getCacheModelStr(int8_t cacheModel) {




567,169✔





3053



  switch (cacheModel) {




567,169✔





3054



    case TSDB_CACHE_MODEL_NONE:




510,312✔





3055



      return TSDB_CACHE_MODEL_NONE_STR;




510,312✔





3056



    case TSDB_CACHE_MODEL_LAST_ROW:




3,426✔





3057



      return TSDB_CACHE_MODEL_LAST_ROW_STR;




3,426✔





3058



    case TSDB_CACHE_MODEL_LAST_VALUE:




6,859✔





3059



      return TSDB_CACHE_MODEL_LAST_VALUE_STR;




6,859✔





3060



    case TSDB_CACHE_MODEL_BOTH:




46,572✔





3061



      return TSDB_CACHE_MODEL_BOTH_STR;




46,572✔






UNCOV

3062



    default:




×








UNCOV

3063



      break;




×







3064



  }











UNCOV

3065



  return "unknown";




×







3066



}










3067












3068



static void getEncryptAlgorithmStr(SMnode *pMnode, int8_t encryptAlgorithm, char *out) {




567,169✔





3069



  switch (encryptAlgorithm) {




567,169✔





3070



    case TSDB_ENCRYPT_ALGO_NONE: {




566,226✔





3071



      tstrncpy(out, TSDB_ENCRYPT_ALGO_NONE_STR, TSDB_ENCRYPT_ALGR_NAME_LEN);




566,226✔





3072



      break;




566,226✔





3073



    }










3074



    default: {




943✔





3075



      SEncryptAlgrObj *obj = mndAcquireEncryptAlgrById(pMnode, encryptAlgorithm);




943✔





3076



      if (obj != NULL) {




943✔





3077



        tstrncpy(out, obj->algorithm_id, TSDB_ENCRYPT_ALGR_NAME_LEN);




943✔





3078



        mndReleaseEncryptAlgr(pMnode, obj);




943✔





3079



      }










3080



      break;




943✔





3081



    }










3082



  }










3083



}




567,169✔





3084












3085



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




2,139,795✔





3086



  if (pDb->cfg.replications == 1) return true;




2,139,795✔





3087












3088



  SSdb *pSdb = pMnode->pSdb;




437,516✔





3089



  void *pIter = NULL;




437,516✔





3090



  bool  isReady = true;




437,516✔





3091



  while (1) {




2,070,271✔





3092



    SVgObj *pVgroup = NULL;




2,507,787✔





3093



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




2,507,787✔





3094



    if (pIter == NULL) break;




2,507,787✔





3095












3096



    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {




2,070,271✔





3097



      bool hasLeader = false;




1,256,912✔





3098



      for (int32_t i = 0; i < pVgroup->replica; ++i) {




4,967,428✔





3099



        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||




3,710,516✔





3100



            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {




3,270,372✔





3101



          hasLeader = true;




440,144✔





3102



        }










3103



      }










3104



      if (!hasLeader) isReady = false;




1,256,912✔





3105



    }










3106



    sdbRelease(pSdb, pVgroup);




2,070,271✔





3107



  }










3108












3109



  return isReady;




437,516✔





3110



}










3111












3112



static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,




1,533,096✔





3113



                              int64_t numOfTables, bool sysDb, ESdbStatus objStatus, bool sysinfo,










3114



                              SSHashObj **ppUidNames) {










3115



  int32_t cols = 0;




1,533,096✔





3116



  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;




1,533,096✔





3117



  char   *buf = taosMemoryMalloc(bytes);




1,533,096✔





3118



  if (buf == NULL) {




1,533,096✔






UNCOV

3119



    mError("db:%s, failed to malloc buffer", pDb->name);




×








UNCOV

3120



    return;




×







3121



  }










3122



  int32_t code = 0;




1,533,096✔





3123



  int32_t lino = 0;




1,533,096✔





3124












3125



  const char *name = mndGetDbStr(pDb->name);




1,533,096✔





3126



  if (name != NULL) {




1,533,096✔





3127



    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);




1,533,096✔





3128



  } else {










3129



    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);




×







3130



  }










3131












3132



  const char *precStr = NULL;




1,533,096✔





3133



  switch (pDb->cfg.precision) {




1,533,096✔





3134



    case TSDB_TIME_PRECISION_MILLI:




1,488,518✔





3135



      precStr = TSDB_TIME_PRECISION_MILLI_STR;




1,488,518✔





3136



      break;




1,488,518✔





3137



    case TSDB_TIME_PRECISION_MICRO:




11,961✔





3138



      precStr = TSDB_TIME_PRECISION_MICRO_STR;




11,961✔





3139



      break;




11,961✔





3140



    case TSDB_TIME_PRECISION_NANO:




32,617✔





3141



      precStr = TSDB_TIME_PRECISION_NANO_STR;




32,617✔





3142



      break;




32,617✔






UNCOV

3143



    default:




×








UNCOV

3144



      precStr = "none";




×








UNCOV

3145



      break;




×







3146



  }










3147



  char precVstr[10] = {0};




1,533,096✔





3148



  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);




1,533,096✔





3149












3150



  char *statusStr = "ready";




1,533,096✔





3151



  if (objStatus == SDB_STATUS_CREATING) {




1,533,096✔






UNCOV

3152



    statusStr = "creating";




×







3153



  } else if (objStatus == SDB_STATUS_DROPPING) {




1,533,096✔






UNCOV

3154



    statusStr = "dropping";




×







3155



  } else {










3156



    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {




1,533,096✔





3157



      statusStr = "unsynced";




2,134✔





3158



    }










3159



  }










3160



  char statusVstr[24] = {0};




1,533,096✔





3161



  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);




1,533,096✔





3162












3163



  if (sysDb || !sysinfo) {




1,533,096✔





3164



    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {




40,566,904✔





3165



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




39,600,977✔





3166



      if (i == 0) {




39,601,412✔





3167



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




965,927✔





3168



      } else if (i == 1) {




38,635,485✔





3169



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




965,927✔





3170



      } else if (i == 3) {




37,669,558✔





3171



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




965,927✔





3172



      } else if (i == 14) {




36,703,631✔





3173



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);




965,927✔





3174



      } else if (i == 15) {




35,737,704✔





3175



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);




965,927✔





3176



      } else if (i == 28) {




34,771,777✔





3177



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




965,927✔





3178



      } else {










3179



        colDataSetNULL(pColInfo, rows);




33,805,850✔





3180



      }










3181



    }










3182



  } else {










3183



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




567,169✔





3184



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




567,169✔





3185












3186



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




567,169✔





3187



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




567,169✔





3188












3189



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




567,169✔





3190



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);




567,169✔





3191












3192



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




567,169✔





3193



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




567,169✔





3194












3195



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




567,169✔





3196



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);




567,169✔





3197












3198



    const char *strictStr = pDb->cfg.strict ? "on" : "off";




567,169✔





3199



    char        strictVstr[24] = {0};




567,169✔





3200



    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);




567,169✔





3201



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




567,169✔





3202



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);




567,169✔





3203












3204



    char    durationStr[128] = {0};




567,169✔





3205



    char    durationVstr[128] = {0};




567,169✔





3206



    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,




567,169✔





3207



                                       pDb->cfg.daysPerFile);










3208












3209



    varDataSetLen(durationVstr, len);




567,169✔





3210



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




567,169✔





3211



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




567,169✔





3212












3213



    char keepVstr[128] = {0};




567,169✔





3214



    char keep0Str[32] = {0};




567,169✔





3215



    char keep1Str[32] = {0};




567,169✔





3216



    char keep2Str[32] = {0};




567,169✔





3217












3218



    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);




567,169✔





3219



    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);




567,169✔





3220



    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);




567,169✔





3221












3222



    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {




567,169✔






UNCOV

3223



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep1Str,




×







3224



                     keep2Str, keep0Str);










3225



    } else {










3226



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep0Str,




567,169✔





3227



                     keep1Str, keep2Str);










3228



    }










3229



    varDataSetLen(keepVstr, len);




567,169✔





3230



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




567,169✔





3231



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);




567,169✔





3232












3233



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




567,169✔





3234



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);




567,169✔





3235












3236



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




567,169✔





3237



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);




567,169✔





3238












3239



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




567,169✔





3240



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);




567,169✔





3241












3242



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




567,169✔





3243



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);




567,169✔





3244












3245



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




567,169✔





3246



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);




567,169✔





3247












3248



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




567,169✔





3249



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);




567,169✔





3250












3251



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




567,169✔





3252



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);




567,169✔





3253












3254



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




567,169✔





3255



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);




567,169✔





3256












3257



    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);




567,169✔





3258



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




567,169✔





3259



    if (rentensionVstr == NULL) {




567,169✔





3260



      colDataSetNULL(pColInfo, rows);




567,169✔





3261



    } else {











UNCOV

3262



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false), &lino, _OVER);




×








UNCOV

3263



      taosMemoryFree(rentensionVstr);




×







3264



    }










3265












3266



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




567,169✔





3267



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);




567,169✔





3268












3269



    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);




567,169✔





3270



    char        cacheModelVstr[24] = {0};




567,169✔





3271



    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);




567,169✔





3272



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




567,169✔





3273



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);




567,169✔





3274












3275



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




567,169✔





3276



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);




567,169✔





3277












3278



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




567,169✔





3279



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastShardBits, false), &lino, _OVER);




567,169✔





3280












3281



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




567,169✔





3282



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);




567,169✔





3283












3284



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




567,169✔





3285



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);




567,169✔





3286












3287



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




567,169✔





3288



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);




567,169✔





3289












3290



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




567,169✔





3291



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);




567,169✔





3292












3293



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




567,169✔





3294



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);




567,169✔





3295












3296



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




567,169✔





3297



    int16_t hashPrefix = pDb->cfg.hashPrefix;




567,169✔





3298



    if (hashPrefix > 0) {




567,169✔





3299



      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;




3,385✔





3300



    } else if (hashPrefix < 0) {




563,784✔





3301



      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;




5,264✔





3302



    }










3303



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);




567,169✔





3304












3305



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




567,169✔





3306



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);




567,169✔





3307












3308



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




567,169✔





3309



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);




567,169✔





3310












3311



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




567,169✔





3312



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




567,169✔





3313












3314



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




567,169✔





3315



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssChunkSize, false), &lino, _OVER);




567,169✔





3316












3317



    char keeplocalVstr[128] = {0};




567,169✔





3318



    len = snprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr) - VARSTR_HEADER_SIZE, "%dm",




567,169✔





3319



                   pDb->cfg.ssKeepLocal);










3320



    varDataSetLen(keeplocalVstr, len);




567,169✔





3321



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




567,169✔





3322



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);




567,169✔





3323












3324



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




567,169✔





3325



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssCompact, false), &lino, _OVER);




567,169✔





3326












3327



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




567,169✔





3328



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);




567,169✔





3329












3330



    char encryptAlgorithmStr[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




567,169✔





3331



    getEncryptAlgorithmStr(pMnode, pDb->cfg.encryptAlgorithm, encryptAlgorithmStr);




567,169✔





3332



    char        encryptAlgorithmVStr[24] = {0};




567,169✔





3333



    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);




567,169✔





3334



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




567,169✔





3335



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);




567,169✔





3336












3337



    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));




567,169✔





3338



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




567,169✔





3339



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




567,169✔





3340



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




567,169✔





3341



    }










3342












3343



    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);




567,169✔





3344



    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));




567,169✔





3345



    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));




567,169✔





3346



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




567,169✔





3347



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




567,169✔





3348



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




567,169✔





3349



    }










3350












3351



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));




567,169✔





3352



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




567,169✔





3353



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




567,169✔





3354



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




567,169✔





3355



    }










3356












3357



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




567,169✔





3358



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.isAudit, false), &lino, _OVER);




567,169✔





3359



    }










3360












3361



    if (!(*ppUidNames)) {




567,169✔





3362



      TAOS_CHECK_GOTO(mndBuildUidNamesHash(pMnode, ppUidNames), &lino, _OVER);




320,086✔





3363



    }










3364



    const char *ownerName = tSimpleHashGet(*ppUidNames, (const char *)&pDb->ownerId, sizeof(pDb->ownerId));




567,169✔





3365



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%s", ownerName ? ownerName : "[unknown]"));




567,169✔





3366



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




567,169✔





3367



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




567,169✔





3368



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




567,169✔





3369



    }










3370












3371



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




567,169✔





3372



      uint8_t allowDrop = pDb->cfg.allowDrop;




567,169✔





3373



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&allowDrop, false), &lino, _OVER);




567,169✔





3374



    }










3375



  }










3376



_OVER:




1,533,096✔





3377



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




1,533,096✔





3378



  taosMemoryFree(buf);




1,533,096✔





3379



}










3380












3381



static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




480,638✔





3382



  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));




480,638✔





3383



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




480,638✔





3384



  pDbObj->cfg.numOfVgroups = 0;




480,638✔





3385



  pDbObj->cfg.strict = 1;




480,638✔





3386



  pDbObj->cfg.replications = 1;




480,638✔





3387



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




480,638✔





3388



}




480,638✔





3389












3390



static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




480,638✔





3391



  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));




480,638✔





3392



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




480,638✔





3393



  pDbObj->cfg.numOfVgroups = 0;




480,638✔





3394



  pDbObj->cfg.strict = 1;




480,638✔





3395



  pDbObj->cfg.replications = 1;




480,638✔





3396



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




480,638✔





3397



}




480,638✔





3398












3399



static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {




4,696,351✔





3400



  SVgObj  *pVgroup = pObj;




4,696,351✔





3401



  int32_t *numOfTables = p1;




4,696,351✔





3402



  int64_t  uid = *(int64_t *)p2;




4,696,351✔





3403



  if (pVgroup->dbUid == uid) {




4,696,351✔





3404



    *numOfTables += pVgroup->numOfTables;




1,522,259✔





3405



  }










3406



  return true;




4,696,351✔





3407



}










3408












3409



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




480,638✔





3410



  SMnode    *pMnode = pReq->info.node;




480,638✔





3411



  SSdb      *pSdb = pMnode->pSdb;




480,638✔





3412



  int32_t    numOfRows = 0;




480,638✔





3413



  SDbObj    *pDb = NULL;




480,638✔





3414



  SUserObj  *pOperUser = NULL;




480,638✔





3415



  ESdbStatus objStatus = 0;




480,638✔





3416



  SSHashObj *pUidNames = NULL;




480,638✔





3417












3418



  (void)mndAcquireUser(pMnode, RPC_MSG_USER(pReq), &pOperUser);




480,638✔





3419



  if (pOperUser == NULL) return 0;




480,638✔





3420



  bool sysinfo = pOperUser->sysInfo;




480,638✔





3421



  char objFName[TSDB_OBJ_FNAME_LEN + 1] = {0};




480,638✔





3422



  (void)snprintf(objFName, sizeof(objFName), "%d.*", pOperUser->acctId);




480,638✔





3423



  bool showAnyDb = (0 == mndCheckSysObjPrivilege(pMnode, pOperUser, RPC_MSG_TOKEN(pReq), PRIV_CM_SHOW, PRIV_OBJ_DB, 0,




480,638✔





3424



                                                 objFName, NULL));










3425












3426



  // Append the information_schema database into the result.










3427



  if (!pShow->sysDbRsp) {




480,638✔





3428



    SDbObj infoschemaDb = {0};




480,638✔





3429



    setInformationSchemaDbCfg(pMnode, &infoschemaDb);




480,638✔





3430



    size_t numOfTables = 0;




480,638✔





3431



    getVisibleInfosTablesNum(sysinfo, &numOfTables);




480,638✔





3432



    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




480,638✔





3433












3434



    numOfRows += 1;




480,638✔





3435












3436



    SDbObj perfschemaDb = {0};




480,638✔





3437



    setPerfSchemaDbCfg(pMnode, &perfschemaDb);




480,638✔





3438



    numOfTables = 0;




480,638✔





3439



    getPerfDbMeta(NULL, &numOfTables);




480,638✔





3440



    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




480,638✔





3441












3442



    numOfRows += 1;




480,638✔





3443



    pShow->sysDbRsp = true;




480,638✔





3444



  }










3445












3446



  while (numOfRows < rowsCapacity) {




1,052,458✔





3447



    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);




1,052,458✔





3448



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




1,052,458✔





3449



    if (showAnyDb || mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SHOW_DATABASES, pDb) == 0) {




571,820✔





3450



      int32_t numOfTables = 0;




571,820✔





3451



      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);




571,820✔





3452



      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo, &pUidNames);




571,820✔





3453



      numOfRows++;




571,820✔





3454



    }










3455












3456



    sdbRelease(pSdb, pDb);




571,820✔





3457



  }










3458












3459



  pShow->numOfRows += numOfRows;




480,638✔





3460



  mndReleaseUser(pMnode, pOperUser);




480,638✔





3461



  tSimpleHashCleanup(pUidNames);




480,638✔





3462



  return numOfRows;




480,638✔





3463



}










3464













UNCOV

3465



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




×








UNCOV

3466



  SSdb *pSdb = pMnode->pSdb;




×








UNCOV

3467



  sdbCancelFetchByType(pSdb, pIter, SDB_DB);




×








UNCOV

3468



}




×





















    

  • 

    •