taosdata / TDengine / #4988

coverage: 75.821% (+1.9%) from 73.883%
#4988

push

travis-ci

web-flow 
feat: support secure delete option. (#34591)

274 of 464 new or added lines in 29 files covered. (59.05%)

4404 existing lines in 23 files now uncovered.

337108 of 444611 relevant lines covered (75.82%)

146708292.94 hits per line

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

80.97
/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 12










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




917,168✔





77



  SSdbTable table = {




917,168✔





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




917,168✔





89



  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);




917,168✔





90



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);




917,168✔





91



  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);




917,168✔





92



  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);




917,168✔





93



  mndSetMsgHandle(pMnode, TDMT_MND_SCAN_DB, mndProcessScanDbReq);




917,168✔





94



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);




917,168✔





95



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB_WAL, mndProcessTrimDbWalReq);




917,168✔





96



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);




917,168✔





97



  mndSetMsgHandle(pMnode, TDMT_MND_SSMIGRATE_DB, mndProcessSsMigrateDbReq);




917,168✔





98



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);




917,168✔





99












100



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);




917,168✔





101



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);




917,168✔





102












103



  return sdbSetTable(pMnode->pSdb, table);




917,168✔





104



}










105












106



void mndCleanupDb(SMnode *pMnode) {}




917,030✔





107












108



SSdbRaw *mndDbActionEncode(SDbObj *pDb) {




12,651,346✔





109



  int32_t code = 0;




12,651,346✔





110



  int32_t lino = 0;




12,651,346✔





111



  terrno = TSDB_CODE_OUT_OF_MEMORY;




12,651,346✔





112












113



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




12,651,346✔





114



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




12,651,346✔





115



  if (pRaw == NULL) goto _OVER;




12,651,346✔





116












117



  int32_t dataPos = 0;




12,651,346✔





118



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




12,651,346✔





119



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




12,651,346✔





120



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




12,651,346✔





121



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




12,651,346✔





122



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




12,651,346✔





123



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




12,651,346✔





124



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




12,651,346✔





125



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




12,651,346✔





126



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




12,651,346✔





127



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




12,651,346✔





128



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




12,651,346✔





129



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




12,651,346✔





130



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




12,651,346✔





131



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




12,651,346✔





132



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




12,651,346✔





133



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




12,651,346✔





134



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




12,651,346✔





135



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




12,651,346✔





136



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




12,651,346✔





137



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




12,651,346✔





138



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




12,651,346✔





139



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




12,651,346✔





140



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




12,651,346✔





141



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




12,651,346✔





142



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




12,651,346✔





143



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




12,651,346✔





144



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




12,651,346✔





145



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




12,651,346✔





146



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




12,651,346✔





147



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




12,651,346✔





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)




12,651,346✔





155



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




12,651,346✔





156



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




12,651,346✔





157



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




12,651,346✔





158



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




12,651,346✔





159



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




12,651,346✔





160



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




12,651,346✔





161



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




12,651,346✔





162



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




12,651,346✔





163



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




12,651,346✔





164



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




12,651,346✔





165



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




12,651,346✔





166



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




12,651,346✔





167



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




12,651,346✔





168



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




12,651,346✔





169



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




12,651,346✔





170



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




12,651,346✔





171



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




12,651,346✔





172



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




12,651,346✔





173



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




12,651,346✔





174



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




12,651,346✔





175



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




12,651,346✔






176



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




12,651,346✔





177












178



  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




12,651,346✔





179



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




12,651,346✔





180



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




12,651,346✔





181












182



  SDB_SET_DATALEN(pRaw, dataPos, _OVER)




12,651,346✔





183












184



  terrno = 0;




12,651,346✔





185












186



_OVER:




12,651,346✔





187



  if (terrno != 0) {




12,651,346✔






UNCOV

188



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




×







189



    sdbFreeRaw(pRaw);




×







190



    return NULL;




×







191



  }










192












193



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




12,651,346✔





194



  return pRaw;




12,651,346✔





195



}










196












197



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {




11,410,448✔





198



  int32_t code = 0;




11,410,448✔





199



  int32_t lino = 0;




11,410,448✔





200



  terrno = TSDB_CODE_OUT_OF_MEMORY;




11,410,448✔





201



  SSdbRow *pRow = NULL;




11,410,448✔





202



  SDbObj  *pDb = NULL;




11,410,448✔





203












204



  int8_t sver = 0;




11,410,448✔





205



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




11,410,448✔





206












207



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




11,410,448✔






UNCOV

208



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







209



    goto _OVER;




×







210



  }










211












212



  pRow = sdbAllocRow(sizeof(SDbObj));




11,410,448✔





213



  if (pRow == NULL) goto _OVER;




11,410,448✔





214












215



  pDb = sdbGetRowObj(pRow);




11,410,448✔





216



  if (pDb == NULL) goto _OVER;




11,410,448✔





217












218



  int32_t dataPos = 0;




11,410,448✔





219



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




11,410,448✔





220



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




11,410,448✔





221



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




11,410,448✔





222



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




11,410,448✔





223



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




11,410,448✔





224



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




11,410,448✔





225



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




11,410,448✔





226



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




11,410,448✔





227



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




11,410,448✔





228



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




11,410,448✔





229



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




11,410,448✔





230



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




11,410,448✔





231



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




11,410,448✔





232



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




11,410,448✔





233



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




11,410,448✔





234



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




11,410,448✔





235



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




11,410,448✔





236



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




11,410,448✔





237



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




11,410,448✔





238



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




11,410,448✔





239



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




11,410,448✔





240



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




11,410,448✔





241



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




11,410,448✔





242



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




11,410,448✔





243



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




11,410,448✔





244



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




11,410,448✔





245



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




11,410,448✔





246



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




11,410,448✔





247



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




11,410,448✔





248



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




11,410,448✔






UNCOV

249



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




×







250



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




×







251



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




×







252



      SRetention retention = {0};




×







253



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




×







254



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




×







255



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




×







256



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




×







257



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




×







258



        goto _OVER;




×







259



      }










260



    }










261



  }










262



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




11,410,448✔





263



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




11,410,448✔





264



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




11,410,448✔





265



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




11,410,448✔





266



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




11,410,448✔





267



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




11,410,448✔





268



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




11,410,448✔





269



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




11,410,448✔





270



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




11,410,448✔





271



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




11,410,448✔





272



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




11,410,448✔





273



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




11,410,448✔





274



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




11,410,448✔





275



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




11,410,448✔





276



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




11,410,448✔





277



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




11,410,448✔





278



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




11,410,448✔





279



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




11,410,448✔





280



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




11,410,448✔





281



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




11,410,448✔





282



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




11,410,448✔





283



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




11,410,448✔






284



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




11,410,448✔






285



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




11,410,448✔





286



  }










287



  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




11,410,448✔





288



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




11,410,448✔





289



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




11,410,448✔





290



  }










291



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




11,410,448✔





292



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




11,410,448✔





293



  }










294












295



  taosInitRWLatch(&pDb->lock);




11,410,448✔





296












297



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




11,410,448✔






UNCOV

298



    pDb->cfg.ssChunkSize = TSDB_DEFAULT_SS_CHUNK_SIZE;




×







299













UNCOV

300



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




×







301



  }










302












303



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




11,410,448✔





304



    pDb->cfg.ssKeepLocal = TSDB_DEFAULT_SS_KEEP_LOCAL;




×







305













UNCOV

306



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




×







307



  }










308












309



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




11,410,448✔





310



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




11,410,448✔





311



          TSDB_DEFAULT_TSDB_PAGESIZE);










312



  }










313












314



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




11,410,448✔





315



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




11,143,664✔





316



  }










317












318



  if (sver < DB_VER_SUPPORT_ADVANCED_SECURITY) {




11,410,448✔






UNCOV

319



    pDb->cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




×







320



  }










321












322



  terrno = 0;




11,410,448✔





323












324



_OVER:




11,410,448✔





325



  if (terrno != 0) {




11,410,448✔






UNCOV

326



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




×








UNCOV

327



    taosMemoryFreeClear(pRow);




×








UNCOV

328



    return NULL;




×







329



  }










330












331



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




11,410,448✔





332



  return pRow;




11,410,448✔





333



}










334












335



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




2,602,554✔





336



  SSdb    *pSdb = pMnode->pSdb;




2,602,554✔





337



  SSdbRow *pRow = NULL;




2,602,554✔





338



  SDbObj  *pNewDb = NULL;




2,602,554✔





339



  int      code = -1;




2,602,554✔





340












341



  pRow = mndDbActionDecode(pRaw);




2,602,554✔





342



  if (pRow == NULL) {




2,602,554✔






UNCOV

343



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

344



    if (terrno != 0) code = terrno;




×








UNCOV

345



    goto _OVER;




×







346



  }










347



  pNewDb = sdbGetRowObj(pRow);




2,602,554✔





348



  if (pNewDb == NULL) {




2,602,554✔





349



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

350



    if (terrno != 0) code = terrno;




×








UNCOV

351



    goto _OVER;




×







352



  }










353












354



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




2,602,554✔





355



  if (pOldDb != NULL) {




2,602,554✔






UNCOV

356



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




×








UNCOV

357



    sdbRelease(pMnode->pSdb, pOldDb);




×








UNCOV

358



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

359



    if (terrno != 0) code = terrno;




×







360



    goto _OVER;




×







361



  }










362












363



  code = 0;




2,602,554✔





364



_OVER:




2,602,554✔





365



  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);




2,602,554✔





366



  taosMemoryFreeClear(pRow);




2,602,554✔





367



  return code;




2,602,554✔





368



}










369












370



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




2,927,080✔





371



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




2,927,080✔





372



  return 0;




2,927,080✔





373



}










374












375



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




11,410,448✔





376



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




11,410,448✔





377



  taosArrayDestroy(pDb->cfg.pRetensions);




11,410,448✔





378



  return 0;




11,410,448✔





379



}










380












381



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




4,499,344✔





382



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




4,499,344✔





383



  taosWLockLatch(&pOld->lock);




4,499,344✔





384



  pOld->updateTime = pNew->updateTime;




4,499,344✔





385



  pOld->cfgVersion = pNew->cfgVersion;




4,499,344✔





386



  pOld->vgVersion = pNew->vgVersion;




4,499,344✔





387



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




4,499,344✔





388



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




4,499,344✔





389



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




4,499,344✔





390



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




4,499,344✔





391



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




4,499,344✔





392



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




4,499,344✔





393



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




4,499,344✔





394



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




4,499,344✔





395



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




4,499,344✔





396



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




4,499,344✔





397



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




4,499,344✔





398



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




4,499,344✔





399



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




4,499,344✔





400



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




4,499,344✔





401



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




4,499,344✔





402



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




4,499,344✔





403



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




4,499,344✔





404



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




4,499,344✔





405



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




4,499,344✔





406



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




4,499,344✔





407



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




4,499,344✔





408



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




4,499,344✔





409



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




4,499,344✔





410



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




4,499,344✔





411



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




4,499,344✔





412



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




4,499,344✔





413



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




4,499,344✔





414



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




4,499,344✔





415



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




4,499,344✔





416



  pOld->compactStartTime = pNew->compactStartTime;




4,499,344✔





417



  pOld->tsmaVersion = pNew->tsmaVersion;




4,499,344✔





418



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




4,499,344✔






419



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




4,499,344✔





420



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




4,499,344✔





421



  pOld->ownerId = pNew->ownerId;




4,499,344✔





422



  taosWUnLockLatch(&pOld->lock);




4,499,344✔





423



  return 0;




4,499,344✔





424



}










425












426



static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {




18,759,036✔





427



  SSdb *pSdb = pMnode->pSdb;




18,759,036✔





428



  return sdbGetTableVer(pSdb, SDB_VGROUP);




18,759,036✔





429



}










430












431



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




195,872,800✔





432



  SSdb   *pSdb = pMnode->pSdb;




195,872,800✔





433



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




195,872,668✔





434



  if (pDb == NULL) {




195,872,800✔





435



    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {




6,296,974✔





436



      terrno = TSDB_CODE_MND_DB_NOT_EXIST;




5,964,262✔





437



    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {




332,712✔





438



      terrno = TSDB_CODE_MND_DB_IN_CREATING;




20,962✔





439



    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {




311,750✔





440



      terrno = TSDB_CODE_MND_DB_IN_DROPPING;




311,750✔





441



    } else {











UNCOV

442



      terrno = TSDB_CODE_APP_ERROR;




×








UNCOV

443



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




×







444



    }










445



  }










446



  return pDb;




195,872,800✔





447



}










448












449



SDbObj *mndAcquireAuditDb(SMnode *pMnode) {




96,573,616✔





450



  SSdb      *pSdb = pMnode->pSdb;




96,573,616✔





451



  SDbObj    *pDb = NULL;




96,573,616✔





452



  void      *pIter = NULL;




96,573,616✔





453



  ESdbStatus objStatus = 0;




96,573,616✔





454












455



  while (1) {










456



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




272,018,866✔





457



    if (pIter == NULL) break;




272,018,866✔





458



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




175,450,370✔





459



      sdbCancelFetch(pSdb, pIter);




5,120✔





460



      break;




5,120✔





461



    }










462












463



    sdbRelease(pSdb, pDb);




175,445,250✔





464



  }










465



  return pDb;




96,573,616✔





466



}










467












468



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




214,062,190✔





469



  SSdb *pSdb = pMnode->pSdb;




214,062,190✔





470



  sdbRelease(pSdb, pDb);




214,062,694✔





471



}




214,064,298✔





472












473



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




401,808✔





474



  SDbObj *pDb = mndAcquireDb(pMnode, db);




401,808✔





475



  if (pDb == NULL) {




401,808✔





476



    return false;




2,704✔





477



  } else {










478



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




399,104✔





479



    mndReleaseDb(pMnode, pDb);




399,104✔





480



    pDb = NULL;




399,104✔





481



    return result;




399,104✔





482



  }










483



}










484












485



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




2,526,140✔





486



  char *pos = strstr(dbName, TS_PATH_DELIMITER);




2,526,140✔





487



  if (pos == NULL) {




2,526,140✔






UNCOV

488



    return TSDB_CODE_MND_INVALID_DB;




×







489



  }










490












491



  int32_t acctId;




2,523,500✔





492



  int32_t code = taosStr2int32(dbName, &acctId);




2,526,140✔





493



  if (code != 0) {




2,526,140✔






UNCOV

494



    return code;




×







495



  }










496












497



  if (acctId != pUser->acctId) {




2,526,140✔






UNCOV

498



    return TSDB_CODE_MND_INVALID_DB_ACCT;




×







499



  }










500












501



  return 0;




2,526,140✔





502



}










503












504



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




2,526,140✔





505



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




2,526,140✔





506












507



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




2,526,140✔





508



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




2,526,140✔





509



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




2,526,140✔





510



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




2,526,140✔





511



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




2,526,140✔





512



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




2,526,140✔





513



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




2,526,140✔





514



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




2,526,140✔





515



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




2,526,140✔





516



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




2,526,140✔





517



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




2,526,140✔





518



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




2,526,140✔





519



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




2,526,140✔





520



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




2,526,140✔





521



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




2,526,140✔





522



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




2,526,140✔





523



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




2,526,140✔





524



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




2,524,632✔





525



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




2,524,632✔





526



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




2,524,632✔





527



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




2,524,632✔





528



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




2,524,632✔





529



#ifdef TD_ENTERPRISE










530



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




2,524,632✔





531



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










532



#else










533



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










534



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










535



#endif










536












537



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




2,524,632✔





538



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




2,524,632✔





539



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




2,524,632✔





540



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




2,524,632✔





541



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




2,524,632✔






UNCOV

542



    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×








UNCOV

543



    TAOS_RETURN(code);




×







544



  }










545



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




2,524,632✔





546



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




2,524,632✔





547



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




2,524,632✔





548



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




2,524,632✔





549



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




2,524,632✔





550



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




2,524,632✔





551



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




2,524,632✔





552



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




2,524,632✔





553



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




2,524,632✔





554



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




2,524,632✔





555



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




2,524,632✔





556












557



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




2,524,632✔





558



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




2,524,632✔





559



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




2,524,632✔





560












561



  if (pCfg->compactInterval != 0 &&




2,524,632✔





562



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




7,704✔






UNCOV

563



    return code;




×







564



  if (pCfg->compactStartTime != 0 &&




2,524,632✔





565



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




8,520✔






UNCOV

566



    return code;




×







567



  if (pCfg->compactEndTime != 0 &&




2,524,632✔





568



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




8,520✔






UNCOV

569



    return code;




×







570



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




2,524,632✔





571



    return code;




×







572



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




2,524,632✔






UNCOV

573



    return code;




×







574



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




2,524,632✔





575



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










576












577



  code = 0;




2,524,632✔





578



  TAOS_RETURN(code);




2,524,632✔





579



}










580












581



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




181,606✔





582



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




181,606✔





583



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




181,606✔





584



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




181,606✔





585



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




181,606✔





586



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




181,606✔





587



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




181,606✔





588



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




181,606✔





589



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




181,606✔





590



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




181,606✔





591



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




181,606✔





592



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




181,606✔





593



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




181,606✔






UNCOV

594



    return code;




×







595



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




181,606✔





596



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




181,606✔





597



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




181,606✔





598



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




181,606✔





599



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




181,606✔





600



#ifdef TD_ENTERPRISE










601



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




181,606✔





602



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




181,606✔





603



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




1,502✔





604



      terrno = TSDB_CODE_OPS_NOT_SUPPORT;




1,502✔





605



      return code;




1,502✔





606



    }










607



  }










608



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




180,104✔






UNCOV

609



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;




×








UNCOV

610



    return code;




×







611



  }










612



#else










613



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










614



#endif










615












616



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




180,104✔






UNCOV

617



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×








UNCOV

618



    return code;




×







619



  }










620



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




180,104✔






UNCOV

621



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×







622



    return code;




×







623



  }










624












625



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




180,104✔





626



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




2,624✔





627



    return code;




×







628



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




180,104✔





629



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




180,104✔





630



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




180,104✔





631



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




178,602✔





632



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




178,602✔





633



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




178,602✔





634



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




178,602✔






UNCOV

635



    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×








UNCOV

636



    return code;




×







637



  }










638



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




178,602✔





639



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




178,602✔





640



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




178,602✔





641












642



  if (pNewCfg->compactInterval != 0 &&




178,602✔





643



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




13,842✔






UNCOV

644



    return code;




×







645



  if (pNewCfg->compactStartTime != 0 &&




178,602✔





646



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




9,336✔






UNCOV

647



    return code;




×







648



  if (pNewCfg->compactEndTime != 0 &&




178,602✔





649



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




9,336✔






UNCOV

650



    return code;




×







651



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




178,602✔





652



      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)




9,336✔






UNCOV

653



    return code;




×







654



  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||




178,602✔





655



      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)




178,602✔






UNCOV

656



    return code;




×







657



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




178,602✔





658



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










659












660



  code = 0;




178,602✔





661



  TAOS_RETURN(code);




178,602✔





662



}










663












664



static void mndSetDefaultDbCfg(SDbCfg *pCfg) {




2,524,900✔





665



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




2,524,900✔





666



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




2,524,900✔





667



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




2,524,900✔





668



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




2,524,900✔





669



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




2,524,900✔





670



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




2,524,900✔





671



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




2,524,900✔





672



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




2,524,900✔





673



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




2,524,900✔





674



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




2,524,900✔





675



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




2,524,900✔





676



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




2,524,900✔





677



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




2,524,900✔





678



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




2,524,900✔





679



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




2,524,900✔





680



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




2,524,900✔





681



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




2,524,900✔





682



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




2,524,900✔





683



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




2,524,900✔





684



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




2,524,900✔





685



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




2,524,900✔





686



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




2,524,900✔





687



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




2,524,900✔






UNCOV

688



    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;




×







689



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




2,524,900✔






UNCOV

690



    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;




×







691



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




2,524,900✔





692



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




2,524,900✔





693



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




2,524,900✔





694



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




2,524,900✔





695



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




2,524,900✔





696



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




2,524,900✔





697



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




2,524,900✔





698



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




2,524,900✔





699



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




2,524,900✔





700



}




2,524,900✔





701












702



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




2,513,782✔





703



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




2,513,782✔





704



  if (pDbRaw == NULL) return -1;




2,513,782✔





705












706



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




2,513,782✔





707



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




2,513,782✔





708



  return 0;




2,513,782✔





709



}










710












711



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




2,512,542✔





712



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




7,857,378✔





713



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




5,344,836✔





714



  }










715



  return 0;




2,512,542✔





716



}










717













UNCOV

718



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




×








UNCOV

719



  int32_t  code = 0;




×








UNCOV

720



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




×








UNCOV

721



  if (pDbRaw == NULL) {




×








UNCOV

722



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







723



    if (terrno != 0) code = terrno;




×







724



    TAOS_RETURN(code);




×







725



  }










726



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));




×







727



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));




×







728












729



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




×








UNCOV

730



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




×







731



    if (pVgRaw == NULL) {




×







732



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

733



      if (terrno != 0) code = terrno;




×







734



      TAOS_RETURN(code);




×







735



    }










736



    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));




×







737



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));




×







738



  }










739













UNCOV

740



  if (pDb->cfg.withArbitrator) {




×







741



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




×







742



      SVgObj   *pVgObj = pVgroups + v;




×








UNCOV

743



      SArbGroup arbGroup = {0};




×








UNCOV

744



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




×







745



      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));




×







746



    }










747



  }










748












749



  TAOS_RETURN(code);




×







750



}










751












752



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




2,512,542✔





753



  int32_t  code = 0;




2,512,542✔





754



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




2,512,542✔





755



  if (pDbRaw == NULL) {




2,512,542✔






UNCOV

756



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

757



    if (terrno != 0) code = terrno;




×








UNCOV

758



    TAOS_RETURN(code);




×







759



  }










760



  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));




2,512,542✔





761



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));




2,512,542✔





762












763



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




7,857,378✔





764



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




5,344,836✔





765



    if (pVgRaw == NULL) {




5,344,836✔






UNCOV

766



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

767



      if (terrno != 0) code = terrno;




×








UNCOV

768



      TAOS_RETURN(code);




×







769



    }










770



    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));




5,344,836✔





771



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));




5,344,836✔





772



  }










773












774



  if (pDb->cfg.withArbitrator) {




2,512,542✔





775



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




21,286✔





776



      SVgObj   *pVgObj = pVgroups + v;




12,896✔





777



      SArbGroup arbGroup = {0};




12,896✔





778



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




12,896✔





779



      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));




12,896✔





780



    }










781



  }










782












783



  TAOS_RETURN(code);




2,512,542✔





784



}










785












786



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




2,512,542✔





787



                                        SUserObj *pUserDuped, SArray *pAuditOwnedDbs) {










788



  int32_t  code = 0;




2,512,542✔





789



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




2,512,542✔





790



  if (pDbRaw == NULL) {




2,512,542✔






UNCOV

791



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

792



    if (terrno != 0) code = terrno;




×








UNCOV

793



    TAOS_RETURN(code);




×







794



  }










795



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));




2,512,542✔





796



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));




2,512,542✔





797












798



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




7,857,378✔





799



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




5,344,836✔





800



    if (pVgRaw == NULL) {




5,344,836✔






UNCOV

801



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

802



      if (terrno != 0) code = terrno;




×








UNCOV

803



      TAOS_RETURN(code);




×







804



    }










805



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));




5,344,836✔





806



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));




5,344,836✔





807



  }










808












809



  if (pDb->cfg.withArbitrator) {




2,512,542✔





810



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




21,286✔





811



      SVgObj   *pVgObj = pVgroups + v;




12,896✔





812



      SArbGroup arbGroup = {0};




12,896✔





813



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




12,896✔





814



      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));




12,896✔





815



    }










816



  }










817












818



  if (pUserDuped) {




2,512,542✔





819



    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);




2,512,542✔





820



    if (pUserRaw == NULL) {




2,512,542✔






UNCOV

821



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

822



      if (terrno != 0) code = terrno;




×








UNCOV

823



      TAOS_RETURN(code);




×







824



    }










825



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));




2,512,542✔





826



    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));




2,512,542✔





827



  }










828












829



  if(pAuditOwnedDbs) {




2,512,542✔






UNCOV

830



    int32_t auditOwnedDbSize = taosArrayGetSize(pAuditOwnedDbs);




×








UNCOV

831



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




×








UNCOV

832



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




×








UNCOV

833



      SSdbRaw  *pAuditUserRaw = mndUserActionEncode(pAuditUser);




×








UNCOV

834



      if (pAuditUserRaw == NULL) {




×







835



        TAOS_RETURN(terrno ? terrno : TSDB_CODE_MND_RETURN_VALUE_NULL);




×







836



      }










837



      TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pAuditUserRaw));




×







838



      TAOS_CHECK_RETURN(sdbSetRawStatus(pAuditUserRaw, SDB_STATUS_READY));




×







839



    }










840



  }










841












842



  TAOS_RETURN(code);




2,512,542✔





843



}










844












845



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




2,512,542✔





846



  int32_t code = 0;




2,512,542✔





847



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




7,857,378✔





848



    SVgObj *pVgroup = pVgroups + vg;




5,344,836✔





849












850



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




11,243,128✔





851



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




5,898,292✔





852



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




5,898,292✔





853



    }










854



  }










855












856



  TAOS_RETURN(code);




2,512,542✔





857



}










858












859



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




2,512,542✔





860



  int32_t code = 0;




2,512,542✔





861



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




7,857,378✔





862



    SVgObj *pVgroup = pVgroups + vg;




5,344,836✔





863












864



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




11,243,128✔





865



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




5,898,292✔





866



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




5,898,292✔





867



    }










868



  }










869












870



  TAOS_RETURN(code);




2,512,542✔





871



}










872












873



/**










874



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










875



 *










876



 * @param pMnode










877



 * @param pOperUser










878



 * @param pDb










879



 * @param pAuditOwnedDbs










880



 * @return int32_t










881



 */










882



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




320✔





883



  int32_t   code = 0, lino = 0;




320✔





884



  SSdb     *pSdb = pMnode->pSdb;




320✔





885



  SArray   *auditOwnedDbs = NULL;




320✔





886



  SUserObj *pUser = NULL;




320✔





887



  SUserObj  newUserObj = {0};




320✔





888



  int32_t   sysAuditLen = strlen(TSDB_ROLE_SYSAUDIT) + 1;




320✔





889



  int32_t   sysAuditLogLen = strlen(TSDB_ROLE_SYSAUDIT_LOG) + 1;




320✔





890












891



  void *pIter = NULL;




320✔





892



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




640✔





893



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




320✔






UNCOV

894



      sdbRelease(pSdb, pUser);




×








UNCOV

895



      pUser = NULL;




×








UNCOV

896



      continue;




×







897



    }










898



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




320✔





899



      sdbRelease(pSdb, pUser);




320✔





900



      pUser = NULL;




320✔





901



      continue;




320✔





902



    }











UNCOV

903



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




×








UNCOV

904



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




×








UNCOV

905



      sdbRelease(pSdb, pUser);




×








UNCOV

906



      pUser = NULL;




×








UNCOV

907



      continue;




×







908



    }










909



    TAOS_CHECK_EXIT(mndUserDupObj(pUser, &newUserObj));




×







910



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




×







911



    if (auditOwnedDbs == NULL) {




×







912



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




×








UNCOV

913



      if (auditOwnedDbs == NULL) {




×







914



        TAOS_CHECK_EXIT(terrno);




×







915



      }










916



    }










917



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




×







918



      TAOS_CHECK_EXIT(terrno);




×







919



    }











UNCOV

920



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




×








UNCOV

921



    sdbRelease(pSdb, pUser);




×







922



    pUser = NULL;




×







923



  }










924



  *pAuditOwnedDbs = auditOwnedDbs;




320✔





925



  auditOwnedDbs = NULL;




320✔





926



_exit:




320✔





927



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




320✔





928



  sdbRelease(pSdb, pUser);




320✔





929



  sdbCancelFetch(pSdb, pIter);




320✔





930



  mndUserFreeObj(&newUserObj);




320✔





931



  TAOS_RETURN(code);




320✔





932



}










933












934



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




2,529,396✔





935



  int32_t  code = 0;




2,529,396✔





936



  SArray  *auditOwnedDbs = NULL;




2,529,396✔





937



  SUserObj newUserObj = {0};




2,529,396✔





938



  SDbObj   dbObj = {0};




2,529,396✔





939



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




2,529,396✔





940



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




2,529,396✔





941



  dbObj.createdTime = taosGetTimestampMs();




2,529,396✔





942



  dbObj.updateTime = dbObj.createdTime;




2,529,396✔





943



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




2,529,396✔





944



  dbObj.cfgVersion = 1;




2,529,396✔





945



  dbObj.vgVersion = 1;




2,529,396✔





946



  dbObj.tsmaVersion = 1;




2,529,396✔





947



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




2,529,396✔





948



  dbObj.ownerId = pUser->uid;




2,529,396✔





949



  dbObj.cfg = (SDbCfg){




5,056,152✔





950



      .numOfVgroups = pCreate->numOfVgroups,




2,529,396✔





951



      .numOfStables = pCreate->numOfStables,




2,529,396✔





952



      .buffer = pCreate->buffer,




2,529,396✔





953



      .pageSize = pCreate->pageSize,




2,529,396✔





954



      .pages = pCreate->pages,




2,529,396✔





955



      .cacheLastSize = pCreate->cacheLastSize,




2,529,396✔





956



      .daysPerFile = pCreate->daysPerFile,




2,529,396✔





957



      .daysToKeep0 = pCreate->daysToKeep0,




2,529,396✔





958



      .daysToKeep1 = pCreate->daysToKeep1,




2,529,396✔





959



      .daysToKeep2 = pCreate->daysToKeep2,




2,529,396✔





960



      .keepTimeOffset = pCreate->keepTimeOffset,




2,529,396✔





961



      .minRows = pCreate->minRows,




2,529,396✔





962



      .maxRows = pCreate->maxRows,




2,529,396✔





963



      .walFsyncPeriod = pCreate->walFsyncPeriod,




2,529,396✔





964



      .walLevel = pCreate->walLevel,




2,529,396✔





965



      .precision = pCreate->precision,




2,529,396✔





966



      .compression = pCreate->compression,




2,529,396✔





967



      .replications = pCreate->replications,




2,529,396✔





968



      .strict = pCreate->strict,




2,529,396✔





969



      .cacheLast = pCreate->cacheLast,




2,529,396✔





970



      .hashMethod = 1,










971



      .schemaless = pCreate->schemaless,




2,529,396✔





972



      .walRetentionPeriod = pCreate->walRetentionPeriod,




2,529,396✔





973



      .walRetentionSize = pCreate->walRetentionSize,




2,529,396✔





974



      .walRollPeriod = pCreate->walRollPeriod,




2,529,396✔





975



      .walSegmentSize = pCreate->walSegmentSize,




2,529,396✔





976



      .sstTrigger = pCreate->sstTrigger,




2,529,396✔





977



      .hashPrefix = pCreate->hashPrefix,




2,529,396✔





978



      .hashSuffix = pCreate->hashSuffix,




2,529,396✔





979



      .ssChunkSize = pCreate->ssChunkSize,




2,529,396✔





980



      .ssKeepLocal = pCreate->ssKeepLocal,




2,529,396✔





981



      .ssCompact = pCreate->ssCompact,




2,529,396✔





982



      .tsdbPageSize = pCreate->tsdbPageSize,




2,529,396✔





983



      .withArbitrator = pCreate->withArbitrator,




2,529,396✔





984



      .encryptAlgorithm = pCreate->encryptAlgorithm,




2,529,396✔





985



      .compactInterval = pCreate->compactInterval,




2,529,396✔





986



      .compactStartTime = pCreate->compactStartTime,




2,529,396✔





987



      .compactEndTime = pCreate->compactEndTime,




2,529,396✔





988



      .compactTimeOffset = pCreate->compactTimeOffset,




2,529,396✔





989



      .isAudit = pCreate->isAudit,




2,529,396✔






990



      .secureDelete = pCreate->secureDelete,




2,529,396✔





991



  };










992



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




2,529,396✔





993



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




13,558✔





994



      if (pCreate->isAudit == 1) {




7,348✔






UNCOV

995



        code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




×








UNCOV

996



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




×







997



               pCreate->encryptAlgrName);











UNCOV

998



        TAOS_RETURN(code);




×







999



      }










1000



      dbObj.cfg.encryptAlgorithm = 0;




7,348✔





1001



    } else {










1002



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




6,210✔





1003



      if (pEncryptAlgr != NULL) {




6,210✔





1004



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




4,654✔






UNCOV

1005



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×








UNCOV

1006



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




×







1007



                 pCreate->encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);











UNCOV

1008



          TAOS_RETURN(code);




×







1009



        }










1010



        dbObj.cfg.encryptAlgorithm = pEncryptAlgr->id;




4,654✔





1011



      } else {










1012



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




1,556✔





1013



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




1,556✔





1014



        TAOS_RETURN(code);




1,556✔





1015



      }










1016



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




4,654✔






UNCOV

1017



        code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;




×








UNCOV

1018



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




×








UNCOV

1019



        TAOS_RETURN(code);




×







1020



      }










1021



    }










1022



  } else {










1023



    if (pCreate->isAudit == 1) {




2,515,838✔





1024



      code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




2,940✔





1025



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




2,940✔





1026



             pCreate->encryptAlgrName);










1027



      TAOS_RETURN(code);




2,940✔





1028



    }










1029



  }










1030



  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;




2,524,900✔





1031



  dbObj.cfg.pRetensions = pCreate->pRetensions;




2,524,900✔





1032












1033



  if (pCreate->isAudit == 1) {




2,524,900✔





1034



    if (dbObj.cfg.daysToKeep2 < 2628000) {




320✔






UNCOV

1035



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×








UNCOV

1036



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




×








UNCOV

1037



      TAOS_RETURN(code);




×







1038



    }










1039



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




320✔






UNCOV

1040



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×







1041



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




×







1042



      TAOS_RETURN(code);




×







1043



    }










1044



    dbObj.cfg.allowDrop = TSDB_MIN_DB_ALLOW_DROP;




320✔





1045



  } else {










1046



    dbObj.cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




2,524,580✔





1047



  }










1048












1049



  mndSetDefaultDbCfg(&dbObj.cfg);




2,524,900✔





1050












1051



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




2,524,900✔






UNCOV

1052



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




×








UNCOV

1053



    TAOS_RETURN(code);




×







1054



  }










1055












1056



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




2,524,900✔





1057



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




1,508✔





1058



    TAOS_RETURN(code);




1,508✔





1059



  }










1060












1061



  if (dbObj.cfg.hashPrefix > 0) {




2,523,392✔





1062



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




8,336✔





1063



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




8,336✔





1064



    dbObj.cfg.hashPrefix += dbLen;




8,336✔





1065



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




2,515,056✔





1066



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




9,884✔





1067



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




9,884✔





1068



    dbObj.cfg.hashPrefix -= dbLen;




9,884✔





1069



  }










1070












1071



  SVgObj *pVgroups = NULL;




2,523,392✔





1072



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




2,523,392✔





1073



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




10,850✔





1074



    TAOS_RETURN(code);




10,850✔





1075



  }










1076












1077



  // add database privileges for user










1078



  SUserObj *pNewUserDuped = NULL;




2,512,542✔





1079



#if 0










1080



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










1081



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










1082



  if (!pUser->superUser) {










1083



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










1084



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










1085



                    NULL, _OVER);










1086



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










1087



                    NULL, _OVER);










1088



    pNewUserDuped = &newUserObj;










1089



  }










1090



#else










1091



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










1092



  bool addOwned = false;




2,512,542✔





1093



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




2,512,542✔





1094



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




320✔






UNCOV

1095



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




×







1096



      addOwned = true;




320✔





1097



    }










1098



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




320✔





1099



  } else {










1100



    addOwned = true;




2,512,222✔





1101



  }










1102



  if (addOwned) {




2,512,542✔





1103



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




2,512,542✔





1104



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




2,512,542✔





1105



    pNewUserDuped = &newUserObj;




2,512,542✔





1106



  }










1107



#endif










1108












1109



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




2,512,542✔





1110



  if (pTrans == NULL) {




2,512,542✔






UNCOV

1111



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1112



    if (terrno != 0) code = terrno;




×








UNCOV

1113



    goto _OVER;




×







1114



  }










1115



  // mndTransSetSerial(pTrans);










1116



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




2,512,542✔





1117












1118



  mndTransSetDbName(pTrans, dbObj.name, NULL);




2,512,542✔





1119



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




2,512,542✔





1120












1121



  void   *pIter = NULL;




2,512,542✔





1122



  STrans *exitTrans = NULL;




2,512,542✔





1123












1124



  if (!pUser->superUser) {




2,512,542✔





1125



    while (1) {










1126



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




7,470✔





1127



      if (pIter == NULL) break;




7,470✔





1128













UNCOV

1129



      if (exitTrans->conflict == TRN_CONFLICT_DB &&




×








UNCOV

1130



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




×








UNCOV

1131



        code = TSDB_CODE_MND_TRANS_CONFLICT;




×








UNCOV

1132



        sdbRelease(pMnode->pSdb, exitTrans);




×








UNCOV

1133



        sdbCancelFetch(pMnode->pSdb, pIter);




×








UNCOV

1134



        goto _OVER;




×







1135



      }










1136












1137



      sdbRelease(pMnode->pSdb, exitTrans);




×







1138



    }










1139



  }










1140












1141



  if (dbObj.cfg.isAudit) {




2,512,542✔





1142



    if (dbObj.cfg.numOfVgroups > 1) {




320✔





1143



      code = TSDB_CODE_AUDIT_DB_NOT_MULTI_VGROUP;




×








UNCOV

1144



      TAOS_CHECK_GOTO(code, NULL, _OVER);




×







1145



    }










1146



  }










1147












1148



  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);




2,512,542✔





1149



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




2,512,542✔





1150



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




2,512,542✔





1151



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




2,512,542✔





1152



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




2,512,542✔





1153



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




2,512,542✔





1154



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




2,512,542✔





1155












1156



  if (dbObj.cfg.isAudit) {




2,512,542✔





1157



    if (tsAuditSaveInSelf) {




320✔





1158



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










1159



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




156✔





1160



    }










1161



  }










1162



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




2,512,542✔





1163












1164



_OVER:




2,512,542✔





1165



  taosMemoryFree(pVgroups);




2,512,542✔





1166



  mndUserFreeObj(&newUserObj);




2,512,542✔





1167



  taosArrayDestroyEx(auditOwnedDbs, (FDelete)mndUserFreeObj);




2,512,542✔





1168



  mndTransDrop(pTrans);




2,512,542✔





1169



  TAOS_RETURN(code);




2,512,542✔





1170



}










1171












1172



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




2,553,428✔





1173



  int32_t    code = 0;




2,553,428✔





1174



  SSdb      *pSdb = pMnode->pSdb;




2,553,428✔





1175



  SDnodeObj *pDnode = NULL;




2,553,428✔





1176



  void      *pIter = NULL;




2,553,428✔





1177












1178



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










1179



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




2,553,428✔






UNCOV

1180



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




×








UNCOV

1181



  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {




×








UNCOV

1182



    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×








UNCOV

1183



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




×







1184



           tsEncryptionKeyStat);











UNCOV

1185



    goto _exit;




×







1186



  }










1187












1188



  int64_t curMs = taosGetTimestampMs();




×







1189



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




×








UNCOV

1190



    bool online = false;




×







1191



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




×








UNCOV

1192



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




×








UNCOV

1193



      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1194



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




×







1195



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










1196



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










1197



             tsEncryptionKeyChksum);










1198



      sdbCancelFetch(pSdb, pIter);




×







1199



      sdbRelease(pSdb, pDnode);




×







1200



      break;




×







1201



    }











UNCOV

1202



    sdbRelease(pSdb, pDnode);




×







1203



  }










1204



#else










1205



  if (pReq->encryptAlgorithm != TSDB_ENCRYPT_ALGO_NONE) {










1206



    code = TSDB_CODE_MND_INVALID_DB_OPTION;










1207



    goto _exit;










1208



  }










1209



#endif










1210



_exit:




2,550,788✔





1211



  TAOS_RETURN(code);




2,553,428✔





1212



}










1213












1214



#ifndef TD_ENTERPRISE










1215



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










1216



  if (dnodeListStr[0] != 0) {










1217



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;










1218



    return terrno;










1219



  } else {










1220



    return 0;










1221



  }










1222



}










1223



#endif










1224












1225



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {




2,774,896✔





1226



  SMnode      *pMnode = pReq->info.node;




2,774,896✔





1227



  int32_t      code = -1;




2,774,896✔





1228



  int32_t      lino = 0;




2,774,896✔





1229



  SDbObj      *pDb = NULL;




2,774,896✔





1230



  SUserObj    *pUser = NULL;




2,774,896✔





1231



  SCreateDbReq createReq = {0};




2,774,896✔





1232



  SArray      *dnodeList = NULL;




2,774,896✔





1233



  int64_t      tss = taosGetTimestampMs();




2,774,896✔





1234












1235



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




2,774,896✔





1236



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




2,774,896✔





1237












1238



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




2,774,896✔





1239



#ifdef WINDOWS










1240



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










1241



    terrno = TSDB_CODE_MND_INVALID_PLATFORM;










1242



    goto _OVER;










1243



  }










1244



#endif










1245



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




2,774,896✔





1246












1247



  pDb = mndAcquireDb(pMnode, createReq.db);




2,774,896✔





1248



  if (pDb != NULL) {




2,774,896✔





1249



    if (createReq.ignoreExist) {




202,138✔





1250



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




197,296✔





1251



      code = 0;




197,296✔





1252



      goto _OVER;




197,296✔





1253



    } else {










1254



      code = TSDB_CODE_MND_DB_ALREADY_EXIST;




4,842✔





1255



      goto _OVER;




4,842✔





1256



    }










1257



  } else {










1258



    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {




2,572,758✔





1259



      code = terrno;




18,638✔





1260



      goto _OVER;




18,638✔





1261



    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {




2,554,120✔






UNCOV

1262



      goto _OVER;




×







1263



    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {




2,554,120✔





1264



      // continue










1265



    } else {  // TSDB_CODE_APP_ERROR











UNCOV

1266



      goto _OVER;




×







1267



    }










1268



  }










1269












1270



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




2,554,120✔





1271












1272



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




2,553,428✔





1273












1274



  int32_t nVnodes = createReq.numOfVgroups * createReq.replications;




2,553,428✔





1275



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




2,553,428✔





1276












1277



  if (createReq.replications == 2) {




2,553,428✔





1278



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




11,394✔





1279



  }










1280












1281



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




2,553,428✔





1282












1283



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




2,553,428✔





1284












1285



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




2,529,396✔





1286












1287



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




2,529,396✔






UNCOV

1288



    TAOS_CHECK_GOTO(TSDB_CODE_MND_MOUNT_NOT_EMPTY, &lino, _OVER);




×







1289



  }










1290












1291



  if (createReq.isAudit == 1) {




2,529,396✔





1292



    SDbObj *pAuditDb = mndAcquireAuditDb(pMnode);




3,260✔





1293



    if (pAuditDb != NULL) {




3,260✔





1294



      mndReleaseDb(pMnode, pAuditDb);




×








UNCOV

1295



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




×








UNCOV

1296



      TAOS_CHECK_GOTO(TSDB_CODE_AUDIT_DB_ALREADY_EXIST, &lino, _OVER);




×







1297



    }










1298



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




3,260✔





1299



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




3,260✔





1300



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




×







1301



      TAOS_CHECK_GOTO(TSDB_CODE_MND_INVALID_DB, &lino, _OVER);




×







1302



    }










1303



  }










1304












1305



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




2,529,396✔





1306



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




2,512,542✔





1307












1308



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




2,512,542✔





1309



    SName name = {0};




2,512,542✔





1310



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




2,512,542✔






UNCOV

1311



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




×







1312



    int64_t tse = taosGetTimestampMs();




2,512,542✔





1313



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




2,512,542✔





1314



    duration = duration / 1000;




2,512,542✔





1315



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




2,512,542✔





1316



  }










1317












1318



_OVER:




2,772,256✔





1319



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




2,774,896✔





1320



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




65,058✔





1321



  }










1322












1323



  mndReleaseDb(pMnode, pDb);




2,774,896✔





1324



  mndReleaseUser(pMnode, pUser);




2,774,896✔





1325



  tFreeSCreateDbReq(&createReq);




2,774,896✔





1326



  taosArrayDestroy(dnodeList);




2,774,896✔





1327












1328



  TAOS_RETURN(code);




2,774,896✔





1329



}










1330












1331



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




233,656✔





1332



  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;




233,656✔





1333












1334



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




233,656✔





1335



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




9,610✔





1336



    code = 0;




9,610✔





1337



  }










1338












1339



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




233,656✔





1340



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




4,668✔





1341



    code = 0;




4,668✔





1342



  }










1343












1344



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




233,656✔






UNCOV

1345



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




×








UNCOV

1346



    code = 0;




×







1347



  }










1348












1349



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




233,656✔






UNCOV

1350



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




×







1351



    code = 0;




×







1352



  }










1353












1354



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




233,656✔





1355



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




33,020✔





1356



    code = 0;




33,020✔





1357



  }










1358












1359



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




233,656✔





1360



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




31,518✔





1361



    code = 0;




31,518✔





1362



  }










1363












1364



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




233,656✔





1365



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




25,610✔





1366



    code = 0;




25,610✔





1367



  }










1368












1369



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




233,656✔





1370



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




7,566✔





1371



    code = 0;




7,566✔





1372



  }










1373












1374



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




233,656✔





1375



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




18,064✔





1376



    code = 0;




18,064✔





1377



  }










1378












1379



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




233,656✔





1380



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




18,058✔





1381



    code = 0;




18,058✔





1382



  }










1383












1384



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




233,656✔





1385



#if 1











UNCOV

1386



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1387



#else










1388



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










1389



    code = 0;










1390



#endif










1391



  }










1392












1393



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




233,656✔





1394



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




30,228✔





1395



    code = 0;




30,228✔





1396



  }










1397












1398



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




233,656✔





1399



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




3,734✔





1400



    code = 0;




3,734✔





1401



  }










1402












1403



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




233,656✔





1404



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




11,770✔





1405



    pDb->vgVersion++;




11,770✔





1406



    code = 0;




11,770✔





1407



  }










1408












1409



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




233,656✔





1410



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




2,624✔





1411



    pDb->vgVersion++;




2,624✔





1412



    code = 0;




2,624✔





1413



  }










1414












1415



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




233,656✔





1416



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




3,004✔





1417



    pDb->vgVersion++;




3,004✔





1418



    code = 0;




3,004✔





1419



  }










1420












1421



  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&




233,656✔





1422



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




26,588✔





1423



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




14,962✔





1424



    pDb->vgVersion++;




14,962✔





1425



    code = 0;




14,962✔





1426



  }










1427












1428



  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&




233,656✔





1429



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




3,058✔





1430



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




1,502✔





1431



    pDb->vgVersion++;




1,502✔





1432



    code = 0;




1,502✔





1433



  }










1434












1435



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




233,656✔





1436



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




1,502✔





1437



    pDb->vgVersion++;




1,502✔





1438



    code = 0;




1,502✔





1439



  }










1440












1441



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




233,656✔





1442



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




1,502✔





1443



    pDb->vgVersion++;




1,502✔





1444



    code = 0;




1,502✔





1445



  }










1446












1447



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




233,656✔





1448



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




1,502✔





1449



    pDb->vgVersion++;




1,502✔





1450



    code = 0;




1,502✔





1451



  }










1452












1453



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




233,656✔





1454



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




10,784✔





1455



    pDb->vgVersion++;




10,784✔





1456



    code = 0;




10,784✔





1457



  }










1458












1459



  bool compactTimeRangeChanged = false;




233,656✔





1460



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




233,656✔





1461



      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||




228,988✔





1462



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




228,988✔





1463



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




9,336✔





1464



    compactTimeRangeChanged = true;




9,336✔





1465



    code = 0;




9,336✔





1466



  }










1467












1468



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




233,656✔





1469



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




228,988✔





1470



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




9,336✔





1471



    compactTimeRangeChanged = true;




9,336✔





1472



    code = 0;




9,336✔





1473



  }










1474



  if(compactTimeRangeChanged) {




233,656✔





1475



    pDb->vgVersion++;




9,336✔





1476



  }










1477












1478



  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&




233,656✔





1479



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




18,618✔





1480



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




7,726✔





1481



    pDb->vgVersion++;




7,726✔





1482



    code = 0;




7,726✔





1483



  }










1484












1485



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




233,656✔






UNCOV

1486



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×








UNCOV

1487



    return code;




×







1488



  }










1489












1490



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




233,656✔






UNCOV

1491



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




×







1492



    code = 0;




×







1493



  }










1494













1495



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




233,656✔






1496



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




1,182✔






1497



    pDb->vgVersion++;




1,182✔






1498



    code = 0;




1,182✔





1499



  }










1500












1501



  TAOS_RETURN(code);




233,656✔





1502



}










1503












1504



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




178,438✔





1505



  int32_t  code = 0;




178,438✔





1506



  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);




178,438✔





1507



  if (pRedoRaw == NULL) {




178,438✔






UNCOV

1508



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1509



    if (terrno != 0) code = terrno;




×








UNCOV

1510



    TAOS_RETURN(code);




×







1511



  }










1512



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




178,438✔






UNCOV

1513



    sdbFreeRaw(pRedoRaw);




×








UNCOV

1514



    TAOS_RETURN(code);




×







1515



  }










1516












1517



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




178,438✔






UNCOV

1518



    sdbFreeRaw(pRedoRaw);




×








UNCOV

1519



    TAOS_RETURN(code);




×







1520



  }










1521



  return 0;




178,438✔





1522



}










1523












1524



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




178,438✔





1525



  int32_t  code = 0;




178,438✔





1526



  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);




178,438✔





1527



  if (pCommitRaw == NULL) {




178,438✔






UNCOV

1528



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1529



    if (terrno != 0) code = terrno;




×







1530



    TAOS_RETURN(code);




×







1531



  }










1532



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




178,438✔






UNCOV

1533



    sdbFreeRaw(pCommitRaw);




×








UNCOV

1534



    TAOS_RETURN(code);




×







1535



  }










1536












1537



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




178,438✔






UNCOV

1538



    sdbFreeRaw(pCommitRaw);




×








UNCOV

1539



    TAOS_RETURN(code);




×







1540



  }










1541



  TAOS_RETURN(code);




178,438✔





1542



}










1543












1544



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




178,438✔





1545



  int32_t code = 0, lino = 0;




178,438✔





1546



  SSdb   *pSdb = pMnode->pSdb;




178,438✔





1547



  void   *pIter = NULL;




178,438✔





1548



  SVgObj *pVgroup = NULL;




178,438✔





1549



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




178,438✔





1550












1551



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




178,438✔





1552












1553



  while (1) {










1554



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




1,242,484✔





1555



    if (pIter == NULL) break;




1,242,484✔





1556












1557



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




1,065,502✔





1558



      SVgObj newVgroup = {0};




449,704✔





1559



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




449,704✔





1560



                      _err);










1561












1562



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




448,248✔






UNCOV

1563



        if (pNewDb->cfg.withArbitrator) {




×








UNCOV

1564



          SArbGroup arbGroup = {0};




×








UNCOV

1565



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




×








UNCOV

1566



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




×







1567



        } else {











UNCOV

1568



          SArbGroup arbGroup = {0};




×








UNCOV

1569



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




×








UNCOV

1570



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




×







1571



        }










1572



      }










1573



    }










1574












1575



    sdbRelease(pSdb, pVgroup);




1,064,046✔





1576



  }










1577












1578



  taosArrayDestroy(pArray);




176,982✔





1579



  TAOS_RETURN(code);




176,982✔





1580












1581



_err:




1,456✔





1582



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




1,456✔





1583












1584



  sdbCancelFetch(pSdb, pIter);




1,456✔





1585



  sdbRelease(pSdb, pVgroup);




1,456✔





1586



  taosArrayDestroy(pArray);




1,456✔





1587



  TAOS_RETURN(code);




1,456✔





1588



}










1589












1590



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




178,602✔





1591



  int32_t code = -1;




178,602✔





1592



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




178,602✔





1593



  if (pTrans == NULL) {




178,602✔






UNCOV

1594



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1595



    if (terrno != 0) code = terrno;




×








UNCOV

1596



    TAOS_RETURN(code);




×







1597



  }










1598



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




178,602✔





1599



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




178,602✔





1600












1601



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




178,602✔





1602



  mndTransSetGroupParallel(pTrans);




178,602✔





1603



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




178,602✔





1604



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




178,602✔





1605



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




178,438✔





1606












1607



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




178,438✔





1608



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




178,438✔





1609



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




178,438✔





1610












1611



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




176,982✔





1612



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




176,982✔





1613



  code = 0;




176,982✔





1614












1615



_OVER:




178,602✔





1616



  mndTransDrop(pTrans);




178,602✔





1617



  TAOS_RETURN(code);




178,602✔





1618



}










1619












1620



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {




240,174✔





1621



  SMnode     *pMnode = pReq->info.node;




240,174✔





1622



  int32_t     code = -1;




240,174✔





1623



  SDbObj     *pDb = NULL;




240,174✔





1624



  SAlterDbReq alterReq = {0};




240,174✔





1625



  SDbObj      dbObj = {0};




240,174✔





1626



  int64_t     tss = taosGetTimestampMs();




240,174✔





1627












1628



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




240,174✔





1629












1630



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




240,174✔





1631












1632



  pDb = mndAcquireDb(pMnode, alterReq.db);




240,174✔





1633



  if (pDb == NULL) {




240,174✔





1634



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




1,610✔





1635



    if (terrno != 0) code = terrno;




1,610✔





1636



    goto _OVER;




1,610✔





1637



  }










1638












1639



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




238,564✔





1640












1641



  if (alterReq.replications == 2) {




238,270✔





1642



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




1,502✔





1643



  }










1644












1645



  int32_t numOfTopics = 0;




238,270✔





1646



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




238,270✔





1647












1648



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




238,270✔






UNCOV

1649



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×








UNCOV

1650



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




×







1651



           numOfTopics);











UNCOV

1652



    goto _OVER;




×







1653



  }










1654












1655



  if (pDb->cfg.isMount) {




238,270✔






UNCOV

1656



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×








UNCOV

1657



    goto _OVER;




×







1658



  }










1659












1660



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




238,270✔





1661



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




238,270✔





1662



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




×








UNCOV

1663



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




×







1664



  }










1665












1666



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




238,270✔






UNCOV

1667



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




×







1668



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×







1669



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




×








UNCOV

1670



      goto _OVER;




×







1671



    }











UNCOV

1672



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




×








UNCOV

1673



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×







1674



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




×







1675



      goto _OVER;




×







1676



    }











UNCOV

1677



    if (alterReq.isAudit == 0) {




×








UNCOV

1678



      code = TSDB_CODE_AUDIT_DB_NOT_ALLOW_CHANGE;




×







1679



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




×







1680



      goto _OVER;




×







1681



    }










1682



  }










1683












1684



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




238,270✔





1685



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




6,170✔





1686












1687



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




6,170✔





1688



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




1,556✔





1689



        code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




×







1690



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




×







1691



        goto _OVER;




×







1692



      }










1693



    } else {










1694



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




4,614✔





1695



      if (pEncryptAlgr != NULL) {




4,614✔





1696



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




3,058✔






UNCOV

1697



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×








UNCOV

1698



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




×







1699



                 alterReq.encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);











UNCOV

1700



          goto _OVER;




×







1701



        }










1702



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




3,058✔





1703



          code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




3,058✔





1704



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




3,058✔





1705



          goto _OVER;




3,058✔





1706



        }










1707



      } else {










1708



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




1,556✔





1709



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




1,556✔





1710



        goto _OVER;




1,556✔





1711



      }










1712



    }










1713



  }










1714












1715



  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);




233,656✔





1716



  if (code != 0) {




233,656✔





1717



    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;




52,050✔





1718



    goto _OVER;




52,050✔





1719



  }










1720












1721



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




181,606✔





1722












1723



  dbObj.cfgVersion++;




178,602✔





1724



  dbObj.updateTime = taosGetTimestampMs();




178,602✔





1725



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




178,602✔





1726












1727



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




178,602✔





1728



    // return quickly, operation executed asynchronously










1729



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




10,268✔





1730



  } else {










1731



    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




168,334✔





1732



  }










1733












1734



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




178,602✔





1735



    SName name = {0};




178,602✔





1736



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




178,602✔






UNCOV

1737



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




×







1738












1739



    int64_t tse = taosGetTimestampMs();




178,602✔





1740



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




178,602✔





1741



    duration = duration / 1000;




178,602✔





1742



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




178,602✔





1743



  }










1744












1745



_OVER:




240,174✔





1746



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




240,174✔





1747



    if (terrno != 0) code = terrno;




11,142✔





1748



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




11,142✔





1749



  }










1750












1751



  mndReleaseDb(pMnode, pDb);




240,174✔





1752



  taosArrayDestroy(dbObj.cfg.pRetensions);




240,174✔





1753



  tFreeSAlterDbReq(&alterReq);




240,174✔





1754












1755



  TAOS_RETURN(code);




240,174✔





1756



}










1757












1758



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




8,202,020✔





1759



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




8,202,020✔





1760



  cfgRsp->dbId = pDb->uid;




8,202,020✔





1761



  cfgRsp->ownerId = pDb->ownerId;




8,201,952✔





1762



  cfgRsp->cfgVersion = pDb->cfgVersion;




8,200,518✔





1763



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




8,200,518✔





1764



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




8,202,020✔





1765



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




8,202,020✔





1766



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




8,202,020✔





1767



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




8,202,020✔





1768



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




8,201,952✔





1769



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




8,200,450✔





1770



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




8,201,952✔





1771



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




8,200,450✔





1772



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




8,200,518✔





1773



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




8,200,518✔





1774



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




8,202,020✔





1775



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




8,202,020✔





1776



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




8,202,020✔





1777



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




8,202,020✔





1778



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




8,200,518✔





1779



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




8,202,020✔





1780



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




8,202,020✔





1781



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




8,202,020✔





1782



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




8,202,020✔





1783



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




8,200,518✔





1784



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




8,200,518✔





1785



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




8,201,952✔





1786



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




8,200,518✔





1787



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




8,200,450✔





1788



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




8,201,952✔





1789



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




8,200,518✔





1790



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




8,202,020✔





1791



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




8,201,952✔





1792



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




8,202,020✔





1793



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




8,200,518✔





1794



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




8,200,450✔





1795



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




8,200,518✔





1796



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




8,201,952✔





1797



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




8,200,450✔





1798



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




8,200,450✔





1799



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










1800



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




8,202,020✔





1801



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




8,200,450✔





1802



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




8,202,020✔





1803



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




8,200,518✔





1804



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




8,202,020✔





1805



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




8,200,450✔





1806



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




8,202,020✔






1807



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




8,202,020✔





1808



}




8,201,952✔





1809












1810



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {




9,989,212✔





1811



  SMnode   *pMnode = pReq->info.node;




9,989,212✔





1812



  int32_t   code = -1;




9,989,144✔





1813



  SDbObj   *pDb = NULL;




9,989,144✔





1814



  SDbCfgReq cfgReq = {0};




9,989,144✔





1815



  SDbCfgRsp cfgRsp = {0};




9,989,212✔





1816












1817



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




9,987,642✔





1818












1819



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




9,989,212✔





1820



  if (pRealDb) {




9,989,212✔





1821



    ++pRealDb;




9,989,212✔





1822



  } else {











UNCOV

1823



    pRealDb = &cfgReq.db[0];




×







1824



  }










1825



  if (!IS_SYS_DBNAME(pRealDb)) {




9,989,212✔





1826



    pDb = mndAcquireDb(pMnode, cfgReq.db);




9,120,642✔





1827



    if (pDb == NULL) {




9,122,212✔





1828



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




1,024,050✔





1829



      if (terrno != 0) code = terrno;




1,024,050✔





1830



      goto _OVER;




1,024,050✔





1831



    }










1832












1833



    char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




8,098,162✔





1834



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




8,098,162✔





1835



    mndDumpDbCfgInfo(&cfgRsp, pDb, algrId);




8,098,162✔





1836



  }










1837












1838



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




8,963,660✔





1839



  void   *pRsp = rpcMallocCont(contLen);




8,965,162✔





1840



  if (pRsp == NULL) {




8,963,660✔






UNCOV

1841



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1842



    if (terrno != 0) code = terrno;




×








UNCOV

1843



    goto _OVER;




×







1844



  }










1845












1846



  int32_t ret = 0;




8,963,660✔





1847



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




8,963,660✔






UNCOV

1848



    code = ret;




×








UNCOV

1849



    goto _OVER;




×







1850



  }










1851












1852



  pReq->info.rsp = pRsp;




8,963,660✔





1853



  pReq->info.rspLen = contLen;




8,963,660✔





1854












1855



  code = 0;




8,963,660✔





1856












1857



_OVER:




9,987,710✔





1858












1859



  tFreeSDbCfgRsp(&cfgRsp);




9,989,212✔





1860












1861



  if (code != 0) {




9,986,208✔





1862



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




1,024,050✔





1863



  }










1864












1865



  mndReleaseDb(pMnode, pDb);




9,986,208✔





1866












1867



  TAOS_RETURN(code);




9,989,212✔





1868



}










1869












1870



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




1,372,032✔





1871



  int32_t  code = 0;




1,372,032✔





1872



  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);




1,372,032✔





1873



  if (pRedoRaw == NULL) {




1,372,032✔






UNCOV

1874



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1875



    if (terrno != 0) code = terrno;




×








UNCOV

1876



    return -1;




×







1877



  }










1878



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));




1,372,032✔





1879



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));




1,372,032✔





1880












1881



  SSdb *pSdb = pMnode->pSdb;




1,372,032✔





1882



  void *pIter = NULL;




1,372,032✔





1883












1884



  while (1) {




9,012✔





1885



    SArbGroup *pArbGroup = NULL;




1,381,044✔





1886



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




1,381,044✔





1887



    if (pIter == NULL) break;




1,381,044✔





1888












1889



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




9,012✔





1890



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




9,012✔






UNCOV

1891



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1892



        sdbRelease(pSdb, pArbGroup);




×








UNCOV

1893



        TAOS_RETURN(code);




×







1894



      }










1895



    }










1896












1897



    sdbRelease(pSdb, pArbGroup);




9,012✔





1898



  }










1899












1900



  TAOS_RETURN(code);




1,372,032✔





1901



}










1902












1903



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




1,372,032✔





1904



  int32_t  code = 0;




1,372,032✔





1905



  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);




1,372,032✔





1906



  if (pCommitRaw == NULL) {




1,372,032✔






UNCOV

1907



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1908



    if (terrno != 0) code = terrno;




×








UNCOV

1909



    return -1;




×







1910



  }










1911



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));




1,372,032✔





1912



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));




1,372,032✔





1913












1914



  SSdb *pSdb = pMnode->pSdb;




1,372,032✔





1915



  void *pIter = NULL;




1,372,032✔





1916












1917



  while (1) {




9,012✔





1918



    SArbGroup *pArbGroup = NULL;




1,381,044✔





1919



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




1,381,044✔





1920



    if (pIter == NULL) break;




1,381,044✔





1921












1922



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




9,012✔





1923



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




9,012✔






UNCOV

1924



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1925



        sdbRelease(pSdb, pArbGroup);




×








UNCOV

1926



        TAOS_RETURN(code);




×







1927



      }










1928



    }










1929












1930



    sdbRelease(pSdb, pArbGroup);




9,012✔





1931



  }










1932












1933



  while (1) {




6,961,112✔





1934



    SVgObj *pVgroup = NULL;




8,333,144✔





1935



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




8,333,144✔





1936



    if (pIter == NULL) break;




8,333,144✔





1937












1938



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




6,961,112✔





1939



      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




2,913,468✔





1940



      if (pVgRaw == NULL) {




2,913,468✔






UNCOV

1941



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1942



        sdbRelease(pSdb, pVgroup);




×








UNCOV

1943



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1944



        if (terrno != 0) code = terrno;




×








UNCOV

1945



        TAOS_RETURN(code);




×







1946



      }










1947



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




2,913,468✔






UNCOV

1948



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1949



        sdbRelease(pSdb, pVgroup);




×








UNCOV

1950



        TAOS_RETURN(code);




×







1951



      }










1952



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




2,913,468✔






UNCOV

1953



        sdbCancelFetch(pSdb, pIter);




×







1954



        sdbRelease(pSdb, pVgroup);




×







1955



        TAOS_RETURN(code);




×







1956



      }










1957



    }










1958












1959



    sdbRelease(pSdb, pVgroup);




6,961,112✔





1960



  }










1961












1962



  while (1) {




2,415,152✔





1963



    SStbObj *pStb = NULL;




3,787,184✔





1964



    ESdbStatus status;




3,778,658✔





1965



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




3,787,184✔





1966



    if (pIter == NULL) break;




3,787,184✔





1967












1968



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




2,415,152✔





1969



      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);




1,194,604✔





1970



      if (pStbRaw == NULL) {




1,194,604✔






UNCOV

1971



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1972



        sdbRelease(pSdb, pStbRaw);




×








UNCOV

1973



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

1974



        if (terrno != 0) code = terrno;




×








UNCOV

1975



        return -1;




×







1976



      }










1977



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




1,194,604✔






UNCOV

1978



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

1979



        sdbRelease(pSdb, pStbRaw);




×








UNCOV

1980



        return -1;




×







1981



      }










1982



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




1,194,604✔






UNCOV

1983



        sdbCancelFetch(pSdb, pIter);




×







1984



        sdbRelease(pSdb, pStbRaw);




×







1985



        return -1;




×







1986



      }










1987



    }










1988












1989



    sdbRelease(pSdb, pStb);




2,415,152✔





1990



  }










1991












1992



  TAOS_RETURN(code);




1,372,032✔





1993



}










1994












1995



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




2,913,468✔





1996



  int32_t code = 0;




2,913,468✔





1997



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




5,967,836✔





1998



    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




3,054,368✔





1999



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




3,054,368✔





2000



  }










2001












2002



  TAOS_RETURN(code);




2,913,468✔





2003



}










2004












2005



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




1,372,032✔





2006



  int32_t code = 0;




1,372,032✔





2007



  SSdb   *pSdb = pMnode->pSdb;




1,372,032✔





2008



  void   *pIter = NULL;




1,372,032✔





2009












2010



  while (1) {




6,961,112✔





2011



    SVgObj *pVgroup = NULL;




8,333,144✔





2012



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




8,333,144✔





2013



    if (pIter == NULL) break;




8,333,144✔





2014












2015



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




6,961,112✔





2016



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




2,913,468✔






UNCOV

2017



        sdbCancelFetch(pSdb, pIter);




×








UNCOV

2018



        sdbRelease(pSdb, pVgroup);




×








UNCOV

2019



        TAOS_RETURN(code);




×







2020



      }










2021



    }










2022












2023



    sdbRelease(pSdb, pVgroup);




6,961,112✔





2024



  }










2025












2026



  TAOS_RETURN(code);




1,372,032✔





2027



}










2028












2029



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




2,351,632✔





2030



  int32_t    code = 0;




2,351,632✔





2031



  SDropDbRsp dropRsp = {0};




2,351,632✔





2032



  if (pDb != NULL) {




2,351,632✔





2033



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




1,370,796✔





2034



    dropRsp.uid = pDb->uid;




1,370,796✔





2035



  }










2036












2037



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




2,351,632✔





2038



  void   *pRsp = NULL;




2,351,632✔





2039



  if (useRpcMalloc) {




2,351,632✔





2040



    pRsp = rpcMallocCont(rspLen);




980,836✔





2041



  } else {










2042



    pRsp = taosMemoryMalloc(rspLen);




1,370,796✔





2043



  }










2044












2045



  if (pRsp == NULL) {




2,351,632✔






UNCOV

2046



    code = terrno;




×








UNCOV

2047



    TAOS_RETURN(code);




×







2048



  }










2049












2050



  int32_t ret = 0;




2,351,632✔





2051



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




2,351,632✔





2052



  *pRspLen = rspLen;




2,351,632✔





2053



  *ppRsp = pRsp;




2,351,632✔





2054



  TAOS_RETURN(code);




2,351,632✔





2055



}










2056












2057



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




1,371,544✔





2058



  int32_t code = -1;




1,371,544✔





2059












2060



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




1,371,544✔





2061



  if (pTrans == NULL) {




1,371,544✔






UNCOV

2062



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2063



    if (terrno != 0) code = terrno;




×








UNCOV

2064



    goto _OVER;




×







2065



  }










2066












2067



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




1,371,544✔





2068












2069



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




1,371,544✔





2070



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




1,371,544✔





2071












2072



  if (mndTopicExistsForDb(pMnode, pDb)) {




1,371,544✔





2073



    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;




748✔





2074



    goto _OVER;




748✔





2075



  }










2076












2077



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




1,370,796✔





2078



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




1,370,796✔





2079



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




1,370,796✔





2080



#ifdef TD_ENTERPRISE










2081



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




1,370,796✔





2082



#endif










2083



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




1,370,796✔





2084



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




1,370,796✔





2085



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




1,370,796✔





2086



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










2087



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




1,370,796✔





2088



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




1,370,796✔





2089












2090



  int32_t rspLen = 0;




1,370,796✔





2091



  void   *pRsp = NULL;




1,370,796✔





2092



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




1,370,796✔





2093



  mndTransSetRpcRsp(pTrans, pRsp, rspLen);




1,370,796✔





2094












2095



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




1,370,796✔





2096



  code = 0;




1,370,796✔





2097












2098



_OVER:




1,371,544✔





2099



  mndTransDrop(pTrans);




1,371,544✔





2100



  TAOS_RETURN(code);




1,371,544✔





2101



}










2102












2103



static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {




2,365,080✔





2104



  SMnode    *pMnode = pReq->info.node;




2,365,080✔





2105



  int32_t    code = -1;




2,365,080✔





2106



  SDbObj    *pDb = NULL;




2,365,080✔





2107



  SDropDbReq dropReq = {0};




2,365,080✔





2108



  int64_t    tss = taosGetTimestampMs();




2,365,080✔





2109












2110



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




2,365,080✔





2111












2112



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




2,365,080✔





2113












2114



  pDb = mndAcquireDb(pMnode, dropReq.db);




2,365,080✔





2115



  if (pDb == NULL) {




2,365,080✔





2116



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




988,924✔





2117



    if (terrno != 0) code = terrno;




988,924✔





2118



    int32_t ret =










2119



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




988,924✔





2120



    if (ret != 0) {




988,924✔






UNCOV

2121



      code = ret;




×








UNCOV

2122



      goto _OVER;




×







2123



    }










2124



    if (dropReq.ignoreNotExists) {




988,924✔





2125



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




980,836✔





2126



    }










2127



    goto _OVER;




988,924✔





2128



  }










2129












2130



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




1,376,156✔






UNCOV

2131



    goto _OVER;




×







2132



  }










2133












2134



  if(pDb->cfg.isMount) {




1,376,156✔





2135



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




1,236✔





2136



    goto _OVER;




1,236✔





2137



  }










2138












2139



  if(!pDb->cfg.allowDrop) {




1,374,920✔






UNCOV

2140



    code = TSDB_CODE_MND_DB_DROP_NOT_ALLOWED;




×








UNCOV

2141



    goto _OVER;




×







2142



  }










2143












2144



  SSdb *pSdb = pMnode->pSdb;




1,374,920✔





2145



  void *pIter = NULL;




1,374,920✔





2146












2147



  while (1) {




6,986,088✔





2148



    SVgObj *pVgroup = NULL;




8,361,008✔





2149



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




8,361,008✔





2150



    if (pIter == NULL) break;




8,361,008✔





2151












2152



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




6,986,088✔





2153



      bool isFound = false;




2,915,120✔





2154



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




5,971,140✔





2155



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




3,056,020✔






UNCOV

2156



          isFound = true;




×








UNCOV

2157



          break;




×







2158



        }










2159



      }










2160



      if (!isFound) {




2,915,120✔





2161



        sdbRelease(pSdb, pVgroup);




2,915,120✔





2162



        continue;




2,915,120✔





2163



      }











UNCOV

2164



      code = TSDB_CODE_MND_VGROUP_OFFLINE;




×








UNCOV

2165



      sdbCancelFetch(pSdb, pIter);




×








UNCOV

2166



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2167



      goto _OVER;




×







2168



    }










2169












2170



    sdbRelease(pSdb, pVgroup);




4,070,968✔





2171



  }










2172












2173



  bool dbStream = false;




1,374,920✔





2174



  bool vtableStream = false;




1,374,920✔





2175



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




1,374,920✔





2176



  if (dbStream) {




1,374,920✔





2177



    code = TSDB_CODE_MND_STREAM_DB_IN_USE;




2,896✔





2178



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




2,896✔





2179



    goto _OVER;




2,896✔





2180



  }










2181












2182



  if (vtableStream && !dropReq.force) {




1,372,024✔





2183



    code = TSDB_CODE_MND_STREAM_VTABLE_EXITS;




480✔





2184



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




480✔





2185



    goto _OVER;




480✔





2186



  }










2187












2188



  code = mndDropDb(pMnode, pReq, pDb);




1,371,544✔





2189



  if (code == TSDB_CODE_SUCCESS) {




1,371,544✔





2190



    code = TSDB_CODE_ACTION_IN_PROGRESS;




1,370,796✔





2191



  }










2192












2193



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




1,371,544✔





2194



    SName name = {0};




1,371,544✔





2195



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




1,371,544✔






UNCOV

2196



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




×







2197












2198



    int64_t tse = taosGetTimestampMs();




1,371,544✔





2199



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




1,371,544✔





2200



    duration = duration / 1000;




1,371,544✔





2201



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




1,371,544✔





2202



  }










2203












2204



_OVER:




2,363,038✔





2205



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




2,365,080✔





2206



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




13,448✔





2207



  }










2208












2209



  mndReleaseDb(pMnode, pDb);




2,365,080✔





2210



  tFreeSDropDbReq(&dropReq);




2,365,080✔





2211



  TAOS_RETURN(code);




2,365,080✔





2212



}










2213












2214



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




57,956,266✔





2215



  int32_t numOfTables = 0;




57,956,266✔





2216



  int32_t vindex = 0;




57,956,266✔





2217



  SSdb   *pSdb = pMnode->pSdb;




57,956,266✔





2218












2219



  void *pIter = NULL;




57,956,128✔





2220



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




235,782,026✔





2221



    SVgObj *pVgroup = NULL;




177,825,760✔





2222



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




177,825,760✔





2223



    if (pIter == NULL) break;




177,825,892✔





2224












2225



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




177,825,892✔





2226



      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




116,120,892✔





2227



      vindex++;




116,119,390✔





2228



    }










2229












2230



    sdbRelease(pSdb, pVgroup);




177,824,390✔





2231



  }










2232












2233



  sdbCancelFetch(pSdb, pIter);




57,955,810✔





2234



  return numOfTables;




57,956,272✔





2235



}










2236












2237



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




57,452,046✔





2238



  int32_t vindex = 0;




57,452,046✔





2239



  SSdb   *pSdb = pMnode->pSdb;




57,452,046✔





2240












2241



  void *pIter = NULL;




57,452,046✔





2242



  while (1) {




122,865,430✔





2243



    SVgObj *pVgroup = NULL;




180,317,476✔





2244



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




180,317,476✔





2245



    if (pIter == NULL) break;




180,317,476✔





2246












2247



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




167,717,936✔





2248



      SVgroupInfo vgInfo = {0};




131,849,294✔





2249



      vgInfo.vgId = pVgroup->vgId;




131,849,294✔





2250



      vgInfo.hashBegin = pVgroup->hashBegin;




131,849,294✔





2251



      vgInfo.hashEnd = pVgroup->hashEnd;




131,849,294✔





2252



      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




131,849,294✔





2253



      vgInfo.epSet.numOfEps = pVgroup->replica;




131,849,294✔





2254



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




272,511,456✔





2255



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




140,663,664✔





2256



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




140,662,162✔





2257



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




140,662,162✔





2258



        if (pDnode != NULL) {




140,663,664✔





2259



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




140,599,250✔





2260



          pEp->port = pDnode->port;




140,597,748✔





2261



        }










2262



        mndReleaseDnode(pMnode, pDnode);




140,663,664✔





2263



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




140,663,664✔





2264



          vgInfo.epSet.inUse = gid;




130,895,692✔





2265



        }










2266



      }










2267



      vindex++;




131,849,294✔





2268



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




131,849,294✔






UNCOV

2269



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




×







2270



      }










2271



    }










2272












2273



    sdbRelease(pSdb, pVgroup);




167,717,936✔





2274












2275



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




167,717,936✔





2276



      sdbCancelFetch(pSdb, pIter);




44,852,506✔





2277



      break;




44,852,506✔





2278



    }










2279



  }










2280



}




57,452,046✔





2281












2282



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




45,326,072✔





2283



  int32_t code = 0;




45,326,072✔





2284



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




45,326,072✔





2285



  if (pRsp->pVgroupInfos == NULL) {




45,325,988✔






UNCOV

2286



    code = terrno;




×








UNCOV

2287



    TAOS_RETURN(code);




×







2288



  }










2289












2290



  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




45,326,066✔





2291












2292



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




45,326,072✔





2293



      pReq->stateTs < pDb->stateTs) {




2,603,120✔





2294



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




43,001,706✔





2295



  }










2296












2297



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




45,326,066✔





2298



  pRsp->uid = pDb->uid;




45,326,054✔





2299



  pRsp->vgVersion = pDb->vgVersion;




45,326,066✔





2300



  pRsp->stateTs = pDb->stateTs;




45,326,054✔





2301



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




45,325,372✔





2302



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




45,324,564✔





2303



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




45,324,558✔





2304



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




45,322,966✔





2305



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




45,324,558✔





2306



  TAOS_RETURN(code);




45,323,062✔





2307



}










2308












2309



static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {




57,532,450✔





2310



  SMnode   *pMnode = pReq->info.node;




57,532,450✔





2311



  int32_t   code = -1;




57,532,450✔





2312



  SDbObj   *pDb = NULL;




57,532,450✔





2313



  SUseDbReq usedbReq = {0};




57,532,450✔





2314



  SUseDbRsp usedbRsp = {0};




57,532,450✔





2315












2316



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




57,532,450✔





2317












2318



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




57,532,450✔





2319



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




57,532,450✔





2320



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




11,987,666✔





2321



    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




11,987,666✔





2322



    if (usedbReq.vgVersion < vgVersion) {




11,987,666✔





2323



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




11,972,022✔





2324



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




11,972,022✔





2325












2326



      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);




11,972,022✔





2327



      usedbRsp.vgVersion = vgVersion++;




11,972,022✔





2328



    } else {










2329



      usedbRsp.vgVersion = usedbReq.vgVersion;




15,644✔





2330



    }










2331



    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);




11,987,666✔





2332



    code = 0;




11,987,666✔





2333



  } else {










2334



    pDb = mndAcquireDb(pMnode, usedbReq.db);




45,544,868✔





2335



    if (pDb == NULL) {




45,544,778✔





2336



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




205,318✔





2337



      usedbRsp.uid = usedbReq.dbId;




205,318✔





2338



      usedbRsp.vgVersion = usedbReq.vgVersion;




205,318✔





2339



      usedbRsp.errCode = terrno;




205,318✔





2340












2341



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




205,318✔





2342



      if (terrno != 0) code = terrno;




205,318✔





2343



      goto _OVER;




205,318✔





2344



    } else {










2345



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




45,339,460✔





2346












2347



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




45,326,072✔





2348












2349



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




45,323,050✔





2350



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










2351



      code = 0;




45,326,072✔





2352



    }










2353



  }










2354












2355



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




57,313,738✔





2356



  void   *pRsp = rpcMallocCont(contLen);




57,313,738✔





2357



  if (pRsp == NULL) {




57,313,738✔






UNCOV

2358



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2359



    code = -1;




×








UNCOV

2360



    goto _OVER;




×







2361



  }










2362












2363



  int32_t ret = 0;




57,313,738✔





2364



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




57,313,738✔






UNCOV

2365



    code = ret;




×








UNCOV

2366



    goto _OVER;




×







2367



  }










2368












2369



  pReq->info.rsp = pRsp;




57,313,738✔





2370



  pReq->info.rspLen = contLen;




57,313,738✔





2371












2372



_OVER:




57,531,596✔





2373



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




57,532,364✔





2374



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




218,712✔





2375



  }










2376












2377



  mndReleaseDb(pMnode, pDb);




57,532,364✔





2378



  tFreeSUsedbRsp(&usedbRsp);




57,532,450✔





2379












2380



  TAOS_RETURN(code);




57,530,174✔





2381



}










2382












2383



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




16,783,182✔





2384



  int32_t       code = 0;




16,783,182✔





2385



  SDbHbBatchRsp batchRsp = {0};




16,783,182✔





2386



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




16,783,182✔





2387



  if (batchRsp.pArray == NULL) {




16,783,182✔






UNCOV

2388



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2389



    TAOS_RETURN(code);




×







2390



  }










2391












2392



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




36,268,354✔





2393



    SDbCacheInfo *pDbCacheInfo = &pDbs[i];




19,485,172✔





2394



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




19,485,172✔





2395



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




19,485,172✔





2396



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




19,485,172✔





2397



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




19,485,172✔





2398



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




19,485,034✔





2399



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




19,485,034✔





2400












2401



    SDbHbRsp rsp = {0};




19,485,172✔





2402



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




19,485,034✔





2403



    rsp.dbId = pDbCacheInfo->dbId;




19,485,034✔





2404












2405



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




19,485,034✔





2406



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




18,201,494✔





2407



      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




6,771,232✔





2408



      if (pDbCacheInfo->vgVersion >= vgVersion) {




6,771,370✔





2409



        continue;




6,144,842✔





2410



      }










2411












2412



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




627,518✔





2413



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




627,518✔





2414



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




627,518✔





2415












2416



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




627,518✔





2417



      rsp.useDbRsp->vgVersion = vgVersion++;




627,518✔





2418












2419



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




627,518✔





2420












2421



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




1,255,036✔






UNCOV

2422



        if (terrno != 0) code = terrno;




×








UNCOV

2423



        return code;




×







2424



      }










2425












2426



      continue;




627,518✔





2427



    }










2428












2429



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




12,713,802✔





2430



    if (pDb == NULL) {




12,713,802✔





2431



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




83,602✔





2432



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




83,602✔





2433



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




83,602✔





2434



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




83,602✔





2435



      rsp.useDbRsp->vgVersion = -1;




83,602✔





2436



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




167,204✔






UNCOV

2437



        if (terrno != 0) code = terrno;




×








UNCOV

2438



        return code;




×







2439



      }










2440



      continue;




83,602✔





2441



    }










2442












2443



    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




12,630,200✔





2444












2445



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




12,630,200✔





2446



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




12,477,454✔





2447



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




10,731,820✔





2448



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




10,022,302✔





2449



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










2450



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










2451



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










2452



      mndReleaseDb(pMnode, pDb);




10,022,302✔





2453



      continue;




10,022,302✔





2454



    } else {










2455



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




2,607,898✔





2456



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










2457



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










2458



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










2459



    }










2460












2461



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




2,607,898✔





2462



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




103,858✔





2463



      char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




103,858✔





2464



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




103,858✔





2465



      mndDumpDbCfgInfo(rsp.cfgRsp, pDb, algrId);




103,858✔





2466



    }










2467












2468



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




2,607,898✔





2469



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




1,676,464✔





2470



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




1,676,464✔





2471



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




1,676,464✔





2472



        bool    exist = false;




1,676,464✔





2473



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




1,676,464✔





2474



        if (TSDB_CODE_SUCCESS != code) {




1,676,464✔





2475



          mndReleaseDb(pMnode, pDb);




5,628✔





2476



          if (code != TSDB_CODE_NEED_RETRY) {




5,628✔





2477



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




5,628✔





2478



          } else {











UNCOV

2479



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




×







2480



          }










2481



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




5,628✔





2482



          taosMemoryFreeClear(rsp.pTsmaRsp);




5,628✔





2483



          continue;




5,628✔





2484



        }










2485



        rsp.dbTsmaVersion = pDb->tsmaVersion;




1,670,836✔





2486



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




1,670,836✔





2487



      }










2488



    }










2489












2490



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




2,602,270✔





2491



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




2,518,880✔





2492



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




1,850,800✔





2493



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




1,850,800✔





2494



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




1,850,800✔






UNCOV

2495



        mndReleaseDb(pMnode, pDb);




×








UNCOV

2496



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




×








UNCOV

2497



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




×








UNCOV

2498



        taosMemoryFreeClear(rsp.pTsmaRsp);




×








UNCOV

2499



        continue;




×







2500



      }










2501












2502



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




1,850,800✔





2503



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




1,850,800✔





2504



      rsp.useDbRsp->uid = pDb->uid;




1,850,800✔





2505



      rsp.useDbRsp->vgVersion = pDb->vgVersion;




1,850,800✔





2506



      rsp.useDbRsp->stateTs = pDb->stateTs;




1,850,800✔





2507



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




1,850,800✔





2508



      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;




1,850,800✔





2509



      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;




1,850,800✔





2510



      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;




1,850,800✔





2511



      rsp.useDbRsp->flags = pDb->cfg.flags;




1,850,800✔





2512



    }










2513












2514



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




5,204,540✔






UNCOV

2515



      mndReleaseDb(pMnode, pDb);




×








UNCOV

2516



      if (terrno != 0) code = terrno;




×








UNCOV

2517



      return code;




×







2518



    }










2519



    mndReleaseDb(pMnode, pDb);




2,602,270✔





2520



  }










2521












2522



  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);




16,783,182✔





2523



  void   *pRsp = taosMemoryMalloc(rspLen);




16,783,182✔





2524



  if (pRsp == NULL) {




16,783,182✔






UNCOV

2525



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2526



    tFreeSDbHbBatchRsp(&batchRsp);




×








UNCOV

2527



    return -1;




×







2528



  }










2529



  int32_t ret = 0;




16,783,182✔





2530



  if ((ret = tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp)) < 0) return ret;




16,783,182✔





2531












2532



  *ppRsp = pRsp;




16,783,182✔





2533



  *pRspLen = rspLen;




16,783,182✔





2534












2535



  tFreeSDbHbBatchRsp(&batchRsp);




16,783,182✔





2536



  TAOS_RETURN(code);




16,783,044✔





2537



}










2538












2539



static int32_t mndSetTrimDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t startTs, STimeWindow tw,




72,992✔





2540



                                       SArray *vgroupIds, ETsdbOpType type, ETriggerType triggerType,










2541



                                       STrimDbRsp *pRsp) {










2542



  int32_t code = 0, lino = 0;




72,992✔





2543



  SSdb   *pSdb = pMnode->pSdb;




72,992✔





2544



  void   *pIter = NULL;




72,992✔





2545












2546



  SRetentionObj obj = {.optrType = type, .triggerType = triggerType};  // reuse SCompactObj struct




72,992✔





2547



  TAOS_CHECK_EXIT(mndAddRetentionToTrans(pMnode, pTrans, &obj, pDb, pRsp));




72,992✔





2548












2549



  int32_t j = 0;




72,992✔





2550



  int32_t numOfVgroups = taosArrayGetSize(vgroupIds);




72,992✔





2551



  if (numOfVgroups > 0) {




72,992✔





2552



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




18,024✔





2553



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




13,518✔





2554



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




13,518✔





2555












2556



      if (pVgroup == NULL) {




13,518✔





2557



        mError("db:%s, vgroup:%" PRId64 " not exist", pDb->name, vgId);




4,506✔





2558



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




4,506✔





2559



      } else if (pVgroup->dbUid != pDb->uid) {




9,012✔






UNCOV

2560



        mError("db:%s, vgroup:%" PRId64 " not belong to db:%s", pDb->name, vgId, pDb->name);




×








UNCOV

2561



        sdbRelease(pSdb, pVgroup);




×








UNCOV

2562



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




×







2563



      }










2564



      sdbRelease(pSdb, pVgroup);




9,012✔





2565



    }










2566












2567



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




13,518✔





2568



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




9,012✔





2569



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




9,012✔





2570












2571



      if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




9,012✔






UNCOV

2572



        sdbRelease(pSdb, pVgroup);




×







2573



        TAOS_RETURN(code);




×







2574



      }










2575












2576



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




18,024✔





2577



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




9,012✔





2578



        if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




9,012✔






UNCOV

2579



          sdbRelease(pSdb, pVgroup);




×








UNCOV

2580



          TAOS_RETURN(code);




×







2581



        }










2582



        j++;




9,012✔





2583



      }










2584



      sdbRelease(pSdb, pVgroup);




9,012✔





2585



    }










2586



  } else {










2587



    while (1) {




285,678✔





2588



      SVgObj *pVgroup = NULL;




349,658✔





2589



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




349,658✔





2590



      if (pIter == NULL) break;




349,658✔





2591












2592



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




285,678✔





2593



        if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




146,490✔






UNCOV

2594



          sdbCancelFetch(pSdb, pIter);




×








UNCOV

2595



          sdbRelease(pSdb, pVgroup);




×








UNCOV

2596



          TAOS_RETURN(code);




×







2597



        }










2598












2599



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




297,520✔





2600



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




151,030✔





2601



          if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




151,030✔






UNCOV

2602



            sdbCancelFetch(pSdb, pIter);




×








UNCOV

2603



            sdbRelease(pSdb, pVgroup);




×








UNCOV

2604



            TAOS_RETURN(code);




×







2605



          }










2606



          j++;




151,030✔





2607



        }










2608



      }










2609












2610



      sdbRelease(pSdb, pVgroup);




285,678✔





2611



    }










2612



  }










2613



_exit:




72,992✔





2614



  TAOS_RETURN(code);




72,992✔





2615



}










2616












2617



static int32_t mndBuildTrimDbRsp(STrimDbRsp *rsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




68,486✔





2618



  int32_t code = 0;




68,486✔





2619



  int32_t rspLen = tSerializeSCompactDbRsp(NULL, 0, (SCompactDbRsp *)rsp);




68,486✔





2620



  void   *pRsp = NULL;




68,486✔





2621



  if (useRpcMalloc) {




68,486✔






UNCOV

2622



    pRsp = rpcMallocCont(rspLen);




×







2623



  } else {










2624



    pRsp = taosMemoryMalloc(rspLen);




68,486✔





2625



  }










2626












2627



  if (pRsp == NULL) {




68,486✔






UNCOV

2628



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2629



    TAOS_RETURN(code);




×







2630



  }










2631












2632



  (void)tSerializeSCompactDbRsp(pRsp, rspLen, (SCompactDbRsp *)rsp);




68,486✔





2633



  *pRspLen = rspLen;




68,486✔





2634



  *ppRsp = pRsp;




68,486✔





2635



  TAOS_RETURN(code);




68,486✔





2636



}










2637












2638



int32_t mndTrimDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, STimeWindow tw, SArray *vgroupIds,




82,004✔





2639



                         ETsdbOpType type, ETriggerType triggerType) {










2640



  SSdb      *pSdb = pMnode->pSdb;




82,004✔





2641



  SVgObj    *pVgroup = NULL;




82,004✔





2642



  void      *pIter = NULL;




82,004✔





2643



  int32_t    code = 0, lino = 0;




82,004✔





2644



  STrimDbRsp rsp = {0};




82,004✔





2645



  bool       isExist = false;




82,004✔





2646












2647



  while (1) {




35,682✔





2648



    SRetentionObj *pObj = NULL;




117,686✔





2649



    pIter = sdbFetch(pMnode->pSdb, SDB_RETENTION, pIter, (void **)&pObj);




117,686✔





2650



    if (pIter == NULL) break;




117,686✔





2651












2652



    if (strcmp(pObj->dbname, pDb->name) == 0) {




35,682✔





2653



      isExist = true;




9,012✔





2654



    }










2655



    sdbRelease(pMnode->pSdb, pObj);




35,682✔





2656



  }










2657



  if (isExist) {




82,004✔





2658



    mInfo("trim db:%s already exist", pDb->name);




9,012✔





2659



    TAOS_RETURN(TSDB_CODE_MND_TRIM_ALREADY_EXIST);




9,012✔





2660



  }










2661












2662



  int64_t startTs = taosGetTimestampMs();




72,992✔





2663



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




72,992✔





2664



  if (pTrans == NULL) goto _exit;




72,992✔





2665



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




72,992✔





2666



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




72,992✔





2667



  TAOS_CHECK_EXIT(mndTrancCheckConflict(pMnode, pTrans));




72,992✔





2668



  TAOS_CHECK_EXIT(mndSetTrimDbRedoActions(pMnode, pTrans, pDb, startTs, tw, vgroupIds, type, triggerType, &rsp));




72,992✔





2669



  if (pReq) {




68,486✔





2670



    int32_t rspLen = 0;




68,486✔





2671



    void   *pRsp = NULL;




68,486✔





2672



    rsp.bAccepted = true;




68,486✔





2673



    TAOS_CHECK_EXIT(mndBuildTrimDbRsp(&rsp, &rspLen, &pRsp, false));




68,486✔





2674



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




68,486✔





2675



  }










2676



  TAOS_CHECK_EXIT(mndTransPrepare(pMnode, pTrans));




68,486✔





2677



_exit:




72,992✔





2678



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




72,992✔





2679



    mError("db:%s, failed at line %d to trim db since %s", pDb->name, lino, tstrerror(code));




4,506✔





2680



  }










2681



  mndTransDrop(pTrans);




72,992✔





2682



  TAOS_RETURN(code);




72,992✔





2683



}










2684












2685



#ifdef TD_ENTERPRISE










2686



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




28,538✔





2687



  int32_t   code = 0;




28,538✔





2688



  void     *pIter = NULL;




28,538✔





2689



  SRsmaObj *pRsma = NULL;




28,538✔





2690



  while ((pIter = sdbFetch(pMnode->pSdb, SDB_RSMA, pIter, (void **)&pRsma))) {




28,538✔





2691



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




28,538✔





2692



      sdbRelease(pMnode->pSdb, pRsma);




28,538✔





2693



      sdbCancelFetch(pMnode->pSdb, pIter);




28,538✔





2694



      TAOS_RETURN(code);




28,538✔





2695



    }











UNCOV

2696



    sdbRelease(pMnode->pSdb, pRsma);




×







2697



  }











UNCOV

2698



  TAOS_RETURN(TSDB_CODE_RSMA_NOT_EXIST);




×







2699



}










2700



#endif










2701












2702



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {




45,530✔





2703



  SMnode    *pMnode = pReq->info.node;




45,530✔





2704



  int32_t    code = 0, lino = 0;




45,530✔





2705



  SDbObj    *pDb = NULL;




45,530✔





2706



  STrimDbReq trimReq = {0};




45,530✔





2707



  int64_t    tss = taosGetTimestampMs();




45,530✔





2708












2709



  TAOS_CHECK_EXIT(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq));




45,530✔





2710












2711



  mInfo("db:%s, start to trim, optr:%u, tw:%" PRId64 ",%" PRId64, trimReq.db, trimReq.optrType, trimReq.tw.skey,




45,530✔





2712



        trimReq.tw.ekey);










2713












2714



  pDb = mndAcquireDb(pMnode, trimReq.db);




45,530✔





2715



  if (pDb == NULL) {




45,530✔






UNCOV

2716



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2717



    if (terrno != 0) code = terrno;




×








UNCOV

2718



    TAOS_CHECK_EXIT(code);




×







2719



  }










2720












2721



  TAOS_CHECK_EXIT(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb));




45,530✔





2722












2723



  if (pDb->cfg.isMount) {




45,530✔






UNCOV

2724



    TAOS_CHECK_EXIT(TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT);




×







2725



  }










2726












2727



#ifdef TD_ENTERPRISE










2728



  if (trimReq.optrType == TSDB_OPTR_ROLLUP) {




45,530✔





2729



    TAOS_CHECK_EXIT(mndCheckRsmaInDb(pMnode, pDb));




28,538✔





2730



  }










2731



#endif










2732












2733



  TAOS_CHECK_EXIT(mndTrimDb(pMnode, pReq, pDb, trimReq.tw, trimReq.vgroupIds, trimReq.optrType, trimReq.triggerType));




45,530✔





2734



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




32,012✔





2735












2736



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




32,012✔





2737



    SName name = {0};




32,012✔





2738



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




32,012✔






UNCOV

2739



      mWarn("db:%s, failed at line %d to parse db name", trimReq.db, __LINE__);




×







2740



    }










2741












2742



    char optrType[16] = {0};




32,012✔





2743



    (void)snprintf(optrType, sizeof(optrType), "%u", trimReq.optrType);




32,012✔





2744



    int64_t tse = taosGetTimestampMs();




32,012✔





2745



    double  duration = (double)(tse - tss);




32,012✔





2746



    duration = duration / 1000;




32,012✔





2747



    auditRecord(pReq, pMnode->clusterId, "trimDB", name.dbname, optrType, trimReq.sql, trimReq.sqlLen, duration, 0);




32,012✔





2748



  }










2749












2750



_exit:




45,530✔





2751



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {




45,530✔





2752



    mError("db:%s, failed at line %d to process trim db req since %s, optr:%u", trimReq.db, lino, tstrerror(code),




13,518✔





2753



           trimReq.optrType);










2754



  }










2755












2756



  mndReleaseDb(pMnode, pDb);




45,530✔





2757



  tFreeSTrimDbReq(&trimReq);




45,530✔





2758



  TAOS_RETURN(code);




45,530✔





2759



}










2760












2761



static int32_t mndBuildSsMigrateDbRsp(SSsMigrateDbRsp *pSsMigrateRsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




4,506✔





2762



  int32_t code = 0;




4,506✔





2763



  int32_t rspLen = tSerializeSSsMigrateDbRsp(NULL, 0, pSsMigrateRsp);




4,506✔





2764



  void   *pRsp = NULL;




4,506✔





2765



  if (useRpcMalloc) {




4,506✔






UNCOV

2766



    pRsp = rpcMallocCont(rspLen);




×







2767



  } else {










2768



    pRsp = taosMemoryMalloc(rspLen);




4,506✔





2769



  }










2770












2771



  if (pRsp == NULL) {




4,506✔






UNCOV

2772



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2773



    TAOS_RETURN(code);




×







2774



  }










2775












2776



  (void)tSerializeSSsMigrateDbRsp(pRsp, rspLen, pSsMigrateRsp);




4,506✔





2777



  *pRspLen = rspLen;




4,506✔





2778



  *ppRsp = pRsp;




4,506✔





2779



  TAOS_RETURN(code);




4,506✔





2780



}










2781












2782



static int32_t mndTrimDbWal(SMnode *pMnode, SDbObj *pDb) {




2,280✔





2783



  SSdb   *pSdb = pMnode->pSdb;




2,280✔





2784



  SVgObj *pVgroup = NULL;




2,280✔





2785



  void   *pIter = NULL;




2,280✔





2786



  int32_t code = 0;




2,280✔





2787












2788



  // Iterate through all vgroups in this database










2789



  while (1) {




4,560✔





2790



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




6,840✔





2791



    if (pIter == NULL) break;




6,840✔





2792












2793



    // Check if this vgroup belongs to the database










2794



    if (pVgroup->dbUid != pDb->uid) {




4,560✔






UNCOV

2795



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2796



      continue;




×







2797



    }










2798












2799



    // Prepare message to send to vnode










2800



    int32_t   contLen = sizeof(SMsgHead);




4,560✔





2801



    SMsgHead *pHead = rpcMallocCont(contLen);




4,560✔





2802



    if (pHead == NULL) {




4,560✔






UNCOV

2803



      sdbCancelFetch(pSdb, pVgroup);




×








UNCOV

2804



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2805



      code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2806



      break;




×







2807



    }










2808



    pHead->contLen = htonl(contLen);




4,560✔





2809



    pHead->vgId = htonl(pVgroup->vgId);




4,560✔





2810












2811



    // Send TRIM WAL request to vnode










2812



    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM_WAL, .pCont = pHead, .contLen = contLen};




4,560✔





2813



    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);




4,560✔





2814



    code = tmsgSendReq(&epSet, &rpcMsg);




4,560✔





2815



    if (code != 0) {




4,560✔





2816



      mError("vgId:%d, failed to send vnode-trim-wal request since 0x%x", pVgroup->vgId, code);




×







2817



    } else {










2818



      mInfo("vgId:%d, send vnode-trim-wal request to vnode", pVgroup->vgId);




4,560✔





2819



    }










2820



    sdbRelease(pSdb, pVgroup);




4,560✔





2821



  }










2822












2823



  return code;




2,280✔





2824



}










2825












2826



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq) {




2,280✔





2827



  SMnode    *pMnode = pReq->info.node;




2,280✔





2828



  int32_t    code = -1;




2,280✔





2829



  SDbObj    *pDb = NULL;




2,280✔





2830



  STrimDbReq trimReq = {0};




2,280✔





2831












2832



  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);




2,280✔





2833












2834



  mInfo("db:%s, start to trim WAL", trimReq.db);




2,280✔





2835












2836



  pDb = mndAcquireDb(pMnode, trimReq.db);




2,280✔





2837



  if (pDb == NULL) {




2,280✔






UNCOV

2838



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2839



    if (terrno != 0) code = terrno;




×








UNCOV

2840



    goto _OVER;




×







2841



  }










2842












2843



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb), NULL, _OVER);




2,280✔





2844












2845



  code = mndTrimDbWal(pMnode, pDb);




2,280✔





2846












2847



_OVER:




2,280✔





2848



  if (code != 0) {




2,280✔






UNCOV

2849



    mError("db:%s, failed to process trim db wal req since %s", trimReq.db, terrstr());




×







2850



  }










2851












2852



  mndReleaseDb(pMnode, pDb);




2,280✔





2853



  TAOS_RETURN(code);




2,280✔





2854



}










2855












2856



int32_t mndSsMigrateDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {




4,506✔





2857



  int32_t       code = 0;




4,506✔





2858



  SSsMigrateDbRsp ssMigrateRsp = {0};




4,506✔





2859












2860



  bool  isExist = false;




4,506✔





2861



  void *pIter = NULL;




4,506✔





2862



  while (1) {




×







2863



    SSsMigrateObj *pSsMigrate = NULL;




4,506✔





2864



    pIter = sdbFetch(pMnode->pSdb, SDB_SSMIGRATE, pIter, (void **)&pSsMigrate);




4,506✔





2865



    if (pIter == NULL) break;




4,506✔





2866













UNCOV

2867



    if (strcmp(pSsMigrate->dbname, pDb->name) == 0) {




×








UNCOV

2868



      isExist = true;




×







2869



    }











UNCOV

2870



    sdbRelease(pMnode->pSdb, pSsMigrate);




×







2871



  }










2872



  if (isExist) {




4,506✔






UNCOV

2873



    mInfo("ssmigrate db:%s already exist", pDb->name);




×







2874












2875



    if (pReq) {




×








UNCOV

2876



      int32_t rspLen = 0;




×








UNCOV

2877



      void   *pRsp = NULL;




×








UNCOV

2878



      ssMigrateRsp.ssMigrateId = 0;




×








UNCOV

2879



      ssMigrateRsp.bAccepted = false;




×







2880



      TAOS_CHECK_RETURN(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, true));




×







2881













UNCOV

2882



      pReq->info.rsp = pRsp;




×







2883



      pReq->info.rspLen = rspLen;




×







2884



    }










2885












2886



    return TSDB_CODE_MND_SSMIGRATE_ALREADY_EXIST;




×







2887



  }










2888












2889



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "ssmigrate-db");




4,506✔





2890



  if (pTrans == NULL) {




4,506✔





2891



    mError("failed to create ssmigrate-db trans since %s", terrstr());




×







2892



    goto _OVER;




×







2893



  }










2894












2895



  mInfo("trans:%d, used to ssmigrate db:%s", pTrans->id, pDb->name);




4,506✔





2896



  mndTransSetDbName(pTrans, pDb->name, NULL);




4,506✔





2897



  TAOS_CHECK_GOTO(mndTrancCheckConflict(pMnode, pTrans), NULL, _OVER);




4,506✔





2898












2899



  SSsMigrateObj ssMigrate = { .startTime = taosGetTimestampMs() };




4,506✔





2900



  TAOS_CHECK_GOTO(mndAddSsMigrateToTran(pMnode, pTrans, &ssMigrate, pDb), NULL, _OVER);




4,506✔





2901












2902



  if (pReq) {




4,506✔





2903



    int32_t rspLen = 0;




4,506✔





2904



    void   *pRsp = NULL;




4,506✔





2905



    ssMigrateRsp.ssMigrateId = ssMigrate.id;




4,506✔





2906



    ssMigrateRsp.bAccepted = true;




4,506✔





2907



    TAOS_CHECK_GOTO(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, false), NULL, _OVER);




4,506✔





2908



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




4,506✔





2909



  }










2910












2911



  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;




4,506✔





2912



  code = 0;




4,506✔





2913












2914



_OVER:




4,506✔





2915



  mndTransDrop(pTrans);




4,506✔





2916



  TAOS_RETURN(code);




4,506✔





2917



}










2918












2919












2920



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq) {




5,388✔





2921



  SMnode         *pMnode = pReq->info.node;




5,388✔





2922



  int32_t         code = -1;




5,388✔





2923



  SDbObj         *pDb = NULL;




5,388✔





2924



  SSsMigrateDbReq ssMigrateReq = {0};




5,388✔





2925












2926



  if (!tsSsEnabled) {




5,388✔





2927



    code = TSDB_CODE_OPS_NOT_SUPPORT;




882✔





2928



    goto _OVER;




882✔





2929



  }










2930












2931



  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_SHARED_STORAGE), NULL, _OVER);




4,506✔





2932



  TAOS_CHECK_GOTO(tDeserializeSSsMigrateDbReq(pReq->pCont, pReq->contLen, &ssMigrateReq), NULL, _OVER);




4,506✔





2933












2934



  mInfo("db:%s, start to ssmigrate", ssMigrateReq.db);




4,506✔





2935












2936



  pDb = mndAcquireDb(pMnode, ssMigrateReq.db);




4,506✔





2937



  if (pDb == NULL) {




4,506✔






UNCOV

2938



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

2939



    if (terrno != 0) code = terrno;




×








UNCOV

2940



    goto _OVER;




×







2941



  }










2942












2943



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SSMIGRATE_DB, pDb), NULL, _OVER);




4,506✔





2944












2945



  if(pDb->cfg.isMount) {




4,506✔






UNCOV

2946



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×








UNCOV

2947



    goto _OVER;




×







2948



  }










2949












2950



  code = mndSsMigrateDb(pMnode, pReq, pDb);




4,506✔





2951












2952



_OVER:




5,388✔





2953



  if (code != 0) {




5,388✔





2954



    mError("db:%s, failed to process ssmigrate db req since %s", ssMigrateReq.db, tstrerror(code));




882✔





2955



  }










2956












2957



  mndReleaseDb(pMnode, pDb);




5,388✔





2958



  TAOS_RETURN(code);




5,388✔





2959



}










2960












2961



const char *mndGetDbStr(const char *src) {




49,381,484✔





2962



  char *pos = strstr(src, TS_PATH_DELIMITER);




49,381,484✔





2963



  if (pos != NULL) ++pos;




49,381,484✔





2964



  if (pos == NULL) return src;




49,381,484✔





2965



  return pos;




46,657,642✔





2966



}










2967












2968



const char *mndGetStableStr(const char *src) {




42,802,298✔





2969



  char *pos = strstr(src, TS_PATH_DELIMITER);




42,802,298✔





2970



  if (pos != NULL) ++pos;




42,802,298✔





2971



  if (pos == NULL) return src;




42,802,298✔





2972



  return mndGetDbStr(pos);




42,802,298✔





2973



}










2974













UNCOV

2975



static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {




×








UNCOV

2976



  int64_t v = 0;




×








UNCOV

2977



  switch (unit) {




×








UNCOV

2978



    case 's':




×








UNCOV

2979



      v = val / 1000;




×








UNCOV

2980



      break;




×








UNCOV

2981



    case 'm':




×








UNCOV

2982



      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];




×








UNCOV

2983



      break;




×








UNCOV

2984



    case 'h':




×








UNCOV

2985



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);




×








UNCOV

2986



      break;




×








UNCOV

2987



    case 'd':




×







2988



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);




×







2989



      break;




×







2990



    case 'w':




×







2991



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);




×







2992



      break;




×







2993



    default:




×







2994



      break;




×







2995



  }










2996












2997



  return v;




×







2998



}










2999












3000



static char *buildRetension(SArray *pRetension) {




1,161,724✔





3001



  size_t size = taosArrayGetSize(pRetension);




1,161,724✔





3002



  if (size == 0) {




1,161,724✔





3003



    return NULL;




1,161,724✔





3004



  }










3005












3006



  char       *p1 = taosMemoryCalloc(1, 100);




×







3007



  SRetention *p = taosArrayGet(pRetension, 0);




×







3008













UNCOV

3009



  int32_t len = 2;




×







3010













UNCOV

3011



  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×








UNCOV

3012



  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×








UNCOV

3013



  len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3014













UNCOV

3015



  if (size > 1) {




×








UNCOV

3016



    len += tsnprintf(p1 + len, 100 - len, ",");




×








UNCOV

3017



    p = taosArrayGet(pRetension, 1);




×







3018












3019



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3020



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×








UNCOV

3021



    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3022



  }










3023












3024



  if (size > 2) {




×







3025



    len += tsnprintf(p1 + len, 100 - len, ",");




×







3026



    p = taosArrayGet(pRetension, 2);




×







3027












3028



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3029



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3030



    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3031



  }










3032












3033



  varDataSetLen(p1, len);




×







3034



  return p1;




×







3035



}










3036












3037



static const char *getCacheModelStr(int8_t cacheModel) {




1,161,724✔





3038



  switch (cacheModel) {




1,161,724✔





3039



    case TSDB_CACHE_MODEL_NONE:




1,082,308✔





3040



      return TSDB_CACHE_MODEL_NONE_STR;




1,082,308✔





3041



    case TSDB_CACHE_MODEL_LAST_ROW:




5,432✔





3042



      return TSDB_CACHE_MODEL_LAST_ROW_STR;




5,432✔





3043



    case TSDB_CACHE_MODEL_LAST_VALUE:




12,590✔





3044



      return TSDB_CACHE_MODEL_LAST_VALUE_STR;




12,590✔





3045



    case TSDB_CACHE_MODEL_BOTH:




61,394✔





3046



      return TSDB_CACHE_MODEL_BOTH_STR;




61,394✔





3047



    default:




×








UNCOV

3048



      break;




×







3049



  }











UNCOV

3050



  return "unknown";




×







3051



}










3052












3053



static void getEncryptAlgorithmStr(SMnode *pMnode, int8_t encryptAlgorithm, char *out) {




1,161,724✔





3054



  switch (encryptAlgorithm) {




1,161,724✔





3055



    case TSDB_ENCRYPT_ALGO_NONE: {




1,159,568✔





3056



      tstrncpy(out, TSDB_ENCRYPT_ALGO_NONE_STR, TSDB_ENCRYPT_ALGR_NAME_LEN);




1,159,568✔





3057



      break;




1,159,568✔





3058



    }










3059



    default: {




2,156✔





3060



      SEncryptAlgrObj *obj = mndAcquireEncryptAlgrById(pMnode, encryptAlgorithm);




2,156✔





3061



      if (obj != NULL) {




2,156✔





3062



        tstrncpy(out, obj->algorithm_id, TSDB_ENCRYPT_ALGR_NAME_LEN);




2,156✔





3063



        mndReleaseEncryptAlgr(pMnode, obj);




2,156✔





3064



      }










3065



      break;




2,156✔





3066



    }










3067



  }










3068



}




1,161,724✔





3069












3070



bool mndIsDbReady(SMnode *pMnode, SDbObj *pDb) {




4,390,150✔





3071



  if (pDb->cfg.replications == 1) return true;




4,390,150✔





3072












3073



  SSdb *pSdb = pMnode->pSdb;




902,132✔





3074



  void *pIter = NULL;




902,132✔





3075



  bool  isReady = true;




902,132✔





3076



  while (1) {




4,245,810✔





3077



    SVgObj *pVgroup = NULL;




5,147,942✔





3078



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




5,147,942✔





3079



    if (pIter == NULL) break;




5,147,942✔





3080












3081



    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {




4,245,810✔





3082



      bool hasLeader = false;




2,634,036✔





3083



      for (int32_t i = 0; i < pVgroup->replica; ++i) {




10,431,820✔





3084



        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||




7,797,784✔





3085



            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {




6,852,550✔





3086



          hasLeader = true;




945,234✔





3087



        }










3088



      }










3089



      if (!hasLeader) isReady = false;




2,634,036✔





3090



    }










3091



    sdbRelease(pSdb, pVgroup);




4,245,810✔





3092



  }










3093












3094



  return isReady;




902,132✔





3095



}










3096












3097



static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,




3,157,182✔





3098



                              int64_t numOfTables, bool sysDb, ESdbStatus objStatus, bool sysinfo,










3099



                              SSHashObj **ppUidNames) {










3100



  int32_t cols = 0;




3,157,182✔





3101



  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;




3,157,182✔





3102



  char   *buf = taosMemoryMalloc(bytes);




3,157,182✔





3103



  if (buf == NULL) {




3,157,182✔






UNCOV

3104



    mError("db:%s, failed to malloc buffer", pDb->name);




×








UNCOV

3105



    return;




×







3106



  }










3107



  int32_t code = 0;




3,157,182✔





3108



  int32_t lino = 0;




3,157,182✔





3109












3110



  const char *name = mndGetDbStr(pDb->name);




3,157,182✔





3111



  if (name != NULL) {




3,157,182✔





3112



    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);




3,157,182✔





3113



  } else {











UNCOV

3114



    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);




×







3115



  }










3116












3117



  const char *precStr = NULL;




3,157,182✔





3118



  switch (pDb->cfg.precision) {




3,157,182✔





3119



    case TSDB_TIME_PRECISION_MILLI:




3,064,770✔





3120



      precStr = TSDB_TIME_PRECISION_MILLI_STR;




3,064,770✔





3121



      break;




3,064,770✔





3122



    case TSDB_TIME_PRECISION_MICRO:




25,278✔





3123



      precStr = TSDB_TIME_PRECISION_MICRO_STR;




25,278✔





3124



      break;




25,278✔





3125



    case TSDB_TIME_PRECISION_NANO:




67,134✔





3126



      precStr = TSDB_TIME_PRECISION_NANO_STR;




67,134✔





3127



      break;




67,134✔






UNCOV

3128



    default:




×








UNCOV

3129



      precStr = "none";




×








UNCOV

3130



      break;




×







3131



  }










3132



  char precVstr[10] = {0};




3,157,182✔





3133



  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);




3,157,182✔





3134












3135



  char *statusStr = "ready";




3,157,182✔





3136



  if (objStatus == SDB_STATUS_CREATING) {




3,157,182✔






UNCOV

3137



    statusStr = "creating";




×







3138



  } else if (objStatus == SDB_STATUS_DROPPING) {




3,157,182✔






UNCOV

3139



    statusStr = "dropping";




×







3140



  } else {










3141



    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {




3,157,182✔





3142



      statusStr = "unsynced";




4,138✔





3143



    }










3144



  }










3145



  char statusVstr[24] = {0};




3,157,182✔





3146



  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);




3,157,182✔





3147












3148



  if (sysDb || !sysinfo) {




3,157,182✔





3149



    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {




81,813,778✔





3150



      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);




79,818,320✔





3151



      if (i == 0) {




79,818,320✔





3152



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




1,995,458✔





3153



      } else if (i == 1) {




77,822,862✔





3154



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




1,995,458✔





3155



      } else if (i == 3) {




75,827,404✔





3156



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




1,995,458✔





3157



      } else if (i == 14) {




73,831,946✔





3158



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);




1,995,458✔





3159



      } else if (i == 15) {




71,836,488✔





3160



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);




1,995,458✔





3161



      } else if (i == 28) {




69,841,030✔





3162



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




1,995,458✔





3163



      } else {










3164



        colDataSetNULL(pColInfo, rows);




67,845,572✔





3165



      }










3166



    }










3167



  } else {










3168



    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3169



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




1,161,724✔





3170












3171



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3172



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




1,161,724✔





3173












3174



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3175



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);




1,161,724✔





3176












3177



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3178



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




1,161,724✔





3179












3180



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3181



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);




1,161,724✔





3182












3183



    const char *strictStr = pDb->cfg.strict ? "on" : "off";




1,161,724✔





3184



    char        strictVstr[24] = {0};




1,161,724✔





3185



    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);




1,161,724✔





3186



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3187



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);




1,161,724✔





3188












3189



    char    durationStr[128] = {0};




1,161,724✔





3190



    char    durationVstr[128] = {0};




1,161,724✔





3191



    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,




1,161,724✔





3192



                                       pDb->cfg.daysPerFile);










3193












3194



    varDataSetLen(durationVstr, len);




1,161,724✔





3195



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3196



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




1,161,724✔





3197












3198



    char keepVstr[128] = {0};




1,161,724✔





3199



    char keep0Str[32] = {0};




1,161,724✔





3200



    char keep1Str[32] = {0};




1,161,724✔





3201



    char keep2Str[32] = {0};




1,161,724✔





3202












3203



    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);




1,161,724✔





3204



    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);




1,161,724✔





3205



    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);




1,161,724✔





3206












3207



    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {




1,161,724✔






UNCOV

3208



      len = tsnprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr), "%s,%s,%s", keep1Str, keep2Str, keep0Str);




×







3209



    } else {










3210



      len = tsnprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr), "%s,%s,%s", keep0Str, keep1Str, keep2Str);




1,161,724✔





3211



    }










3212



    varDataSetLen(keepVstr, len);




1,161,724✔





3213



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3214



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);




1,161,724✔





3215












3216



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3217



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);




1,161,724✔





3218












3219



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3220



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);




1,161,724✔





3221












3222



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3223



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);




1,161,724✔





3224












3225



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3226



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);




1,161,724✔





3227












3228



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3229



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);




1,161,724✔





3230












3231



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3232



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);




1,161,724✔





3233












3234



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3235



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);




1,161,724✔





3236












3237



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3238



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);




1,161,724✔





3239












3240



    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);




1,161,724✔





3241



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3242



    if (rentensionVstr == NULL) {




1,161,724✔





3243



      colDataSetNULL(pColInfo, rows);




1,161,724✔





3244



    } else {











UNCOV

3245



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false), &lino, _OVER);




×








UNCOV

3246



      taosMemoryFree(rentensionVstr);




×







3247



    }










3248












3249



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3250



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);




1,161,724✔





3251












3252



    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);




1,161,724✔





3253



    char        cacheModelVstr[24] = {0};




1,161,724✔





3254



    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);




1,161,724✔





3255



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3256



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);




1,161,724✔





3257












3258



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3259



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);




1,161,724✔





3260












3261



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3262



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);




1,161,724✔





3263












3264



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3265



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);




1,161,724✔





3266












3267



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3268



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);




1,161,724✔





3269












3270



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3271



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);




1,161,724✔





3272












3273



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3274



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);




1,161,724✔





3275












3276



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3277



    int16_t hashPrefix = pDb->cfg.hashPrefix;




1,161,724✔





3278



    if (hashPrefix > 0) {




1,161,724✔





3279



      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;




6,868✔





3280



    } else if (hashPrefix < 0) {




1,154,856✔





3281



      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;




10,720✔





3282



    }










3283



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);




1,161,724✔





3284












3285



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3286



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);




1,161,724✔





3287












3288



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3289



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);




1,161,724✔





3290












3291



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3292



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




1,161,724✔





3293












3294



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3295



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssChunkSize, false), &lino, _OVER);




1,161,724✔





3296












3297



    char keeplocalVstr[128] = {0};




1,161,724✔





3298



    len = tsnprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr), "%dm", pDb->cfg.ssKeepLocal);




1,161,724✔





3299



    varDataSetLen(keeplocalVstr, len);




1,161,724✔





3300



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3301



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);




1,161,724✔





3302












3303



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3304



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssCompact, false), &lino, _OVER);




1,161,724✔





3305












3306



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3307



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);




1,161,724✔





3308












3309



    char encryptAlgorithmStr[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




1,161,724✔





3310



    getEncryptAlgorithmStr(pMnode, pDb->cfg.encryptAlgorithm, encryptAlgorithmStr);




1,161,724✔





3311



    char        encryptAlgorithmVStr[24] = {0};




1,161,724✔





3312



    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);




1,161,724✔





3313



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




1,161,724✔





3314



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);




1,161,724✔





3315












3316



    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));




1,161,724✔





3317



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




1,161,724✔





3318



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3319



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




1,161,724✔





3320



    }










3321












3322



    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);




1,161,724✔





3323



    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));




1,161,724✔





3324



    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));




1,161,724✔





3325



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




1,161,724✔





3326



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3327



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




1,161,724✔





3328



    }










3329












3330



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));




1,161,724✔





3331



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




1,161,724✔





3332



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3333



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




1,161,724✔





3334



    }










3335












3336



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3337



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.isAudit, false), &lino, _OVER);




1,161,724✔





3338



    }










3339












3340



    if (!(*ppUidNames)) {




1,161,724✔





3341



      TAOS_CHECK_GOTO(mndBuildUidNamesHash(pMnode, ppUidNames), &lino, _OVER);




663,810✔





3342



    }










3343



    const char *ownerName = tSimpleHashGet(*ppUidNames, (const char *)&pDb->ownerId, sizeof(pDb->ownerId));




1,161,724✔





3344



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%s", ownerName ? ownerName : "[unknown]"));




1,161,724✔





3345



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




1,161,724✔





3346



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3347



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




1,161,724✔





3348



    }










3349












3350



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




1,161,724✔





3351



      uint8_t allowDrop = pDb->cfg.allowDrop;




1,161,724✔





3352



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&allowDrop, false), &lino, _OVER);




1,161,724✔





3353



    }










3354



  }










3355



_OVER:




3,157,182✔





3356



  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));




3,157,182✔





3357



  taosMemoryFree(buf);




3,157,182✔





3358



}










3359












3360



static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




992,814✔





3361



  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));




992,814✔





3362



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




992,814✔





3363



  pDbObj->cfg.numOfVgroups = 0;




992,814✔





3364



  pDbObj->cfg.strict = 1;




992,814✔





3365



  pDbObj->cfg.replications = 1;




992,814✔





3366



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




992,814✔





3367



}




992,814✔





3368












3369



static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




992,814✔





3370



  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));




992,814✔





3371



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




992,814✔





3372



  pDbObj->cfg.numOfVgroups = 0;




992,814✔





3373



  pDbObj->cfg.strict = 1;




992,814✔





3374



  pDbObj->cfg.replications = 1;




992,814✔





3375



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




992,814✔





3376



}




992,814✔





3377












3378



static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {




9,588,056✔





3379



  SVgObj  *pVgroup = pObj;




9,588,056✔





3380



  int32_t *numOfTables = p1;




9,588,056✔





3381



  int64_t  uid = *(int64_t *)p2;




9,588,056✔





3382



  if (pVgroup->dbUid == uid) {




9,588,056✔





3383



    *numOfTables += pVgroup->numOfTables;




3,115,858✔





3384



  }










3385



  return true;




9,588,056✔





3386



}










3387












3388



static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {




992,814✔





3389



  SMnode    *pMnode = pReq->info.node;




992,814✔





3390



  SSdb      *pSdb = pMnode->pSdb;




992,814✔





3391



  int32_t    numOfRows = 0;




992,814✔





3392



  SDbObj    *pDb = NULL;




992,814✔





3393



  SUserObj  *pOperUser = NULL;




992,814✔





3394



  ESdbStatus objStatus = 0;




992,814✔





3395



  SSHashObj *pUidNames = NULL;




992,814✔





3396












3397



  (void)mndAcquireUser(pMnode, RPC_MSG_USER(pReq), &pOperUser);




992,814✔





3398



  if (pOperUser == NULL) return 0;




992,814✔





3399



  bool sysinfo = pOperUser->sysInfo;




992,814✔





3400



  char objFName[TSDB_OBJ_FNAME_LEN + 1] = {0};




992,814✔





3401



  (void)snprintf(objFName, sizeof(objFName), "%d.*", pOperUser->acctId);




992,814✔





3402



  bool showAnyDb = (0 == mndCheckSysObjPrivilege(pMnode, pOperUser, RPC_MSG_TOKEN(pReq), PRIV_CM_SHOW, PRIV_OBJ_DB, 0,




992,814✔





3403



                                                 objFName, NULL));










3404












3405



  // Append the information_schema database into the result.










3406



  if (!pShow->sysDbRsp) {




992,814✔





3407



    SDbObj infoschemaDb = {0};




992,814✔





3408



    setInformationSchemaDbCfg(pMnode, &infoschemaDb);




992,814✔





3409



    size_t numOfTables = 0;




992,814✔





3410



    getVisibleInfosTablesNum(sysinfo, &numOfTables);




992,814✔





3411



    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




992,814✔





3412












3413



    numOfRows += 1;




992,814✔





3414












3415



    SDbObj perfschemaDb = {0};




992,814✔





3416



    setPerfSchemaDbCfg(pMnode, &perfschemaDb);




992,814✔





3417



    numOfTables = 0;




992,814✔





3418



    getPerfDbMeta(NULL, &numOfTables);




992,814✔





3419



    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




992,814✔





3420












3421



    numOfRows += 1;




992,814✔





3422



    pShow->sysDbRsp = true;




992,814✔





3423



  }










3424












3425



  while (numOfRows < rowsCapacity) {




2,164,368✔





3426



    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);




2,164,368✔





3427



    if (pShow->pIter == NULL) break;




2,164,368✔





3428



    if (showAnyDb || mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SHOW_DATABASES, pDb) == 0) {




1,171,554✔





3429



      int32_t numOfTables = 0;




1,171,554✔





3430



      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);




1,171,554✔





3431



      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo, &pUidNames);




1,171,554✔





3432



      numOfRows++;




1,171,554✔





3433



    }










3434












3435



    sdbRelease(pSdb, pDb);




1,171,554✔





3436



  }










3437












3438



  pShow->numOfRows += numOfRows;




992,814✔





3439



  mndReleaseUser(pMnode, pOperUser);




992,814✔





3440



  tSimpleHashCleanup(pUidNames);




992,814✔





3441



  return numOfRows;




992,814✔





3442



}










3443













UNCOV

3444



static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {




×








UNCOV

3445



  SSdb *pSdb = pMnode->pSdb;




×








UNCOV

3446



  sdbCancelFetchByType(pSdb, pIter, SDB_DB);




×








UNCOV

3447



}




×





















    

  • 

    •