taosdata / TDengine / #5026

coverage: 72.966% (-0.04%) from 73.009%
#5026

push

travis-ci

web-flow 
fix: replace \s with [[:space:]] in shell regex for macOS BSD compat (#35162)

6 of 7 new or added lines in 2 files covered. (85.71%)

605 existing lines in 129 files now uncovered.

273168 of 374375 relevant lines covered (72.97%)

129569613.61 hits per line

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

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









16



#define _DEFAULT_SOURCE










17



#include "mndDb.h"










18



#include "audit.h"










19



#include "command.h"










20



#include "mndArbGroup.h"










21



#include "mndCluster.h"










22



#include "mndCompact.h"










23



#include "mndCompactDetail.h"










24



#include "mndConfig.h"










25



#include "mndDnode.h"










26



#include "mndEncryptAlgr.h"










27



#include "mndIndex.h"










28



#include "mndPrivilege.h"










29



#include "mndRetention.h"










30



#include "mndRetentionDetail.h"










31



#include "mndRsma.h"










32



#include "mndScan.h"










33



#include "mndShow.h"










34



#include "mndSma.h"










35



#include "mndSsMigrate.h"










36



#include "mndStb.h"










37



#include "mndStream.h"










38



#include "mndSubscribe.h"










39



#include "mndTopic.h"










40



#include "mndTrans.h"










41



#include "mndUser.h"










42



#include "mndVgroup.h"










43



#include "mndView.h"










44



#include "systable.h"










45



#include "thttp.h"










46



#include "tjson.h"










47












48



#define DB_VER_INITIAL                   1










49



#define DB_VER_SUPPORT_ADVANCED_SECURITY 2










50



#define DB_VER_NUMBER                    DB_VER_SUPPORT_ADVANCED_SECURITY










51












52



#define DB_RESERVE_SIZE 8










53












54



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);










55



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










56



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










57



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










58



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










59












60



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq);










61



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq);










62



static int32_t mndProcessDropDbReq(SRpcMsg *pReq);










63



static int32_t mndProcessUseDbReq(SRpcMsg *pReq);










64



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq);










65



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq);










66



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq);










67



static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq);










68



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










69



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










70



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq);










71












72



#ifndef TD_ENTERPRISE










73



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










74



#endif










75












76



int32_t mndInitDb(SMnode *pMnode) {




487,755✔





77



  SSdbTable table = {




487,755✔





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




487,755✔





89



  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);




487,755✔





90



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);




487,755✔





91



  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);




487,755✔





92



  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);




487,755✔





93



  mndSetMsgHandle(pMnode, TDMT_MND_SCAN_DB, mndProcessScanDbReq);




487,755✔





94



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);




487,755✔





95



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB_WAL, mndProcessTrimDbWalReq);




487,755✔





96



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);




487,755✔





97



  mndSetMsgHandle(pMnode, TDMT_MND_SSMIGRATE_DB, mndProcessSsMigrateDbReq);




487,755✔





98



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);




487,755✔





99












100



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);




487,755✔





101



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);




487,755✔





102












103



  return sdbSetTable(pMnode->pSdb, table);




487,755✔





104



}










105












106



void mndCleanupDb(SMnode *pMnode) {}




487,685✔





107












108



SSdbRaw *mndDbActionEncode(SDbObj *pDb) {




6,867,608✔





109



  int32_t code = 0;




6,867,608✔





110



  int32_t lino = 0;




6,867,608✔





111



  terrno = TSDB_CODE_OUT_OF_MEMORY;




6,867,608✔





112












113



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




6,867,608✔





114



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




6,867,608✔





115



  if (pRaw == NULL) goto _OVER;




6,867,608✔





116












117



  int32_t dataPos = 0;




6,867,608✔





118



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




6,867,608✔





119



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




6,867,608✔





120



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




6,867,608✔





121



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




6,867,608✔





122



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




6,867,608✔





123



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




6,867,608✔





124



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




6,867,608✔





125



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




6,867,608✔





126



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




6,867,608✔





127



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




6,867,608✔





128



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




6,867,608✔





129



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




6,867,608✔





130



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




6,867,608✔





131



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




6,867,608✔





132



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




6,867,608✔





133



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




6,867,608✔





134



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




6,867,608✔





135



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




6,867,608✔





136



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




6,867,608✔





137



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




6,867,608✔





138



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




6,867,608✔





139



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




6,867,608✔





140



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




6,867,608✔





141



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




6,867,608✔





142



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




6,867,608✔





143



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




6,867,608✔





144



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




6,867,608✔





145



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




6,867,608✔





146



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




6,867,608✔





147



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




6,867,608✔





148



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




×







149



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




×







150



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




×







151



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




×







152



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




×







153



  }










154



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




6,867,608✔





155



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




6,867,608✔





156



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




6,867,608✔





157



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




6,867,608✔





158



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




6,867,608✔





159



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




6,867,608✔





160



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




6,867,608✔





161



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




6,867,608✔





162



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




6,867,608✔





163



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




6,867,608✔





164



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




6,867,608✔





165



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




6,867,608✔





166



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




6,867,608✔





167



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




6,867,608✔





168



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




6,867,608✔





169



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




6,867,608✔





170



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




6,867,608✔





171



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




6,867,608✔





172



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




6,867,608✔





173



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




6,867,608✔





174



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




6,867,608✔





175



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




6,867,608✔





176



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




6,867,608✔





177



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




6,867,608✔





178












179



  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




6,867,608✔





180



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




6,867,608✔





181



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




6,867,608✔





182












183



  SDB_SET_DATALEN(pRaw, dataPos, _OVER)




6,867,608✔





184












185



  terrno = 0;




6,867,608✔





186












187



_OVER:




6,867,608✔





188



  if (terrno != 0) {




6,867,608✔





189



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




×







190



    sdbFreeRaw(pRaw);




×







191



    return NULL;




×







192



  }










193












194



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




6,867,608✔





195



  return pRaw;




6,867,608✔





196



}










197












198



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {




6,199,720✔





199



  int32_t code = 0;




6,199,720✔





200



  int32_t lino = 0;




6,199,720✔





201



  terrno = TSDB_CODE_OUT_OF_MEMORY;




6,199,720✔





202



  SSdbRow *pRow = NULL;




6,199,720✔





203



  SDbObj  *pDb = NULL;




6,199,720✔





204












205



  int8_t sver = 0;




6,199,720✔





206



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




6,199,720✔





207












208



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




6,199,720✔





209



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







210



    goto _OVER;




×







211



  }










212












213



  pRow = sdbAllocRow(sizeof(SDbObj));




6,199,720✔





214



  if (pRow == NULL) goto _OVER;




6,199,720✔





215












216



  pDb = sdbGetRowObj(pRow);




6,199,720✔





217



  if (pDb == NULL) goto _OVER;




6,199,720✔





218












219



  int32_t dataPos = 0;




6,199,720✔





220



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




6,199,720✔





221



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




6,199,720✔





222



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




6,199,720✔





223



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




6,199,720✔





224



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




6,199,720✔





225



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




6,199,720✔





226



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




6,199,720✔





227



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




6,199,720✔





228



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




6,199,720✔





229



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




6,199,720✔





230



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




6,199,720✔





231



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




6,199,720✔





232



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




6,199,720✔





233



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




6,199,720✔





234



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




6,199,720✔





235



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




6,199,720✔





236



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




6,199,720✔





237



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




6,199,720✔





238



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




6,199,720✔





239



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




6,199,720✔





240



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




6,199,720✔





241



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




6,199,720✔





242



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




6,199,720✔





243



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




6,199,720✔





244



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




6,199,720✔





245



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




6,199,720✔





246



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




6,199,720✔





247



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




6,199,720✔





248



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




6,199,720✔





249



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




6,199,720✔





250



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




×







251



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




×







252



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




×







253



      SRetention retention = {0};




×







254



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




×







255



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




×







256



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




×







257



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




×







258



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




×







259



        goto _OVER;




×







260



      }










261



    }










262



  }










263



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




6,199,720✔





264



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




6,199,720✔





265



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




6,199,720✔





266



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




6,199,720✔





267



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




6,199,720✔





268



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




6,199,720✔





269



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




6,199,720✔





270



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




6,199,720✔





271



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




6,199,720✔





272



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




6,199,720✔





273



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




6,199,720✔





274



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




6,199,720✔





275



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




6,199,720✔





276



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




6,199,720✔





277



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




6,199,720✔





278



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




6,199,720✔





279



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




6,199,720✔





280



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




6,199,720✔





281



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




6,199,720✔





282



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




6,199,720✔





283



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




6,199,720✔





284



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




6,199,720✔





285



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




6,199,720✔





286



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




6,199,720✔





287












288



  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




6,199,720✔





289



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




6,199,720✔





290



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




6,199,720✔





291



  }










292



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




6,199,720✔





293



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




6,199,720✔





294



  }










295












296



  taosInitRWLatch(&pDb->lock);




6,199,720✔





297












298



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




6,199,720✔





299



    pDb->cfg.ssChunkSize = TSDB_DEFAULT_SS_CHUNK_SIZE;




×







300












301



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




×







302



  }










303












304



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




6,199,720✔





305



    pDb->cfg.ssKeepLocal = TSDB_DEFAULT_SS_KEEP_LOCAL;




×







306












307



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




×







308



  }










309












310



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




6,199,720✔





311



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




6,199,720✔





312



          TSDB_DEFAULT_TSDB_PAGESIZE);










313



  }










314












315



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




6,199,720✔





316



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




6,061,259✔





317



  }










318












319



  if (sver < DB_VER_SUPPORT_ADVANCED_SECURITY) {




6,199,720✔





320



    pDb->cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




×







321



  }










322












323



  terrno = 0;




6,199,720✔





324












325



_OVER:




6,199,720✔





326



  if (terrno != 0) {




6,199,720✔





327



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




×







328



    taosMemoryFreeClear(pRow);




×







329



    return NULL;




×







330



  }










331












332



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




6,199,720✔





333



  return pRow;




6,199,720✔





334



}










335












336



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




1,419,813✔





337



  SSdb    *pSdb = pMnode->pSdb;




1,419,813✔





338



  SSdbRow *pRow = NULL;




1,419,813✔





339



  SDbObj  *pNewDb = NULL;




1,419,813✔





340



  int      code = -1;




1,419,813✔





341












342



  pRow = mndDbActionDecode(pRaw);




1,419,813✔





343



  if (pRow == NULL) {




1,419,813✔





344



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







345



    if (terrno != 0) code = terrno;




×







346



    goto _OVER;




×







347



  }










348



  pNewDb = sdbGetRowObj(pRow);




1,419,813✔





349



  if (pNewDb == NULL) {




1,419,813✔





350



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







351



    if (terrno != 0) code = terrno;




×







352



    goto _OVER;




×







353



  }










354












355



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




1,419,813✔





356



  if (pOldDb != NULL) {




1,419,813✔





357



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




×







358



    sdbRelease(pMnode->pSdb, pOldDb);




×







359



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







360



    if (terrno != 0) code = terrno;




×







361



    goto _OVER;




×







362



  }










363












364



  code = 0;




1,419,813✔





365



_OVER:




1,419,813✔





366



  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);




1,419,813✔





367



  taosMemoryFreeClear(pRow);




1,419,813✔





368



  return code;




1,419,813✔





369



}










370












371



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




1,589,904✔





372



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




1,589,904✔





373



  return 0;




1,589,904✔





374



}










375












376



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




6,199,720✔





377



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




6,199,720✔





378



  taosArrayDestroy(pDb->cfg.pRetensions);




6,199,720✔





379



  return 0;




6,199,720✔





380



}










381












382



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




2,436,331✔





383



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




2,436,331✔





384



  taosWLockLatch(&pOld->lock);




2,436,331✔





385



  pOld->updateTime = pNew->updateTime;




2,436,331✔





386



  pOld->cfgVersion = pNew->cfgVersion;




2,436,331✔





387



  pOld->vgVersion = pNew->vgVersion;




2,436,331✔





388



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




2,436,331✔





389



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




2,436,331✔





390



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




2,436,331✔





391



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




2,436,331✔





392



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




2,436,331✔





393



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




2,436,331✔





394



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




2,436,331✔





395



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




2,436,331✔





396



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




2,436,331✔





397



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




2,436,331✔





398



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




2,436,331✔





399



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




2,436,331✔





400



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




2,436,331✔





401



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




2,436,331✔





402



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




2,436,331✔





403



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




2,436,331✔





404



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




2,436,331✔





405



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




2,436,331✔





406



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




2,436,331✔





407



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




2,436,331✔





408



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




2,436,331✔





409



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




2,436,331✔





410



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




2,436,331✔





411



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




2,436,331✔





412



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




2,436,331✔





413



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




2,436,331✔





414



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




2,436,331✔





415



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




2,436,331✔





416



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




2,436,331✔





417



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




2,436,331✔





418



  pOld->compactStartTime = pNew->compactStartTime;




2,436,331✔





419



  pOld->tsmaVersion = pNew->tsmaVersion;




2,436,331✔





420



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




2,436,331✔





421



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




2,436,331✔





422



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




2,436,331✔





423



  pOld->ownerId = pNew->ownerId;




2,436,331✔





424



  taosWUnLockLatch(&pOld->lock);




2,436,331✔





425



  return 0;




2,436,331✔





426



}










427












428



static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {




10,134,345✔





429



  SSdb *pSdb = pMnode->pSdb;




10,134,345✔





430



  return sdbGetTableVer(pSdb, SDB_VGROUP);




10,134,345✔





431



}










432












433



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




105,386,288✔





434



  SSdb   *pSdb = pMnode->pSdb;




105,386,288✔





435



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




105,386,977✔





436



  if (pDb == NULL) {




105,385,556✔





437



    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {




3,614,389✔





438



      terrno = TSDB_CODE_MND_DB_NOT_EXIST;




3,405,507✔





439



    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {




208,882✔





440



      terrno = TSDB_CODE_MND_DB_IN_CREATING;




12,219✔





441



    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {




196,663✔





442



      terrno = TSDB_CODE_MND_DB_IN_DROPPING;




196,663✔





443



    } else {










444



      terrno = TSDB_CODE_APP_ERROR;




×







445



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




×







446



    }










447



  }










448



  return pDb;




105,384,814✔





449



}










450












451



SDbObj *mndAcquireAuditDb(SMnode *pMnode) {




51,394,749✔





452



  SSdb      *pSdb = pMnode->pSdb;




51,394,749✔





453



  SDbObj    *pDb = NULL;




51,394,749✔





454



  void      *pIter = NULL;




51,394,749✔





455



  ESdbStatus objStatus = 0;




51,394,749✔





456












457



  while (1) {










458



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




147,201,363✔





459



    if (pIter == NULL) break;




147,201,363✔





460



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




95,810,698✔





461



      sdbCancelFetch(pSdb, pIter);




4,084✔





462



      break;




4,084✔





463



    }










464












465



    sdbRelease(pSdb, pDb);




95,806,614✔





466



  }










467



  return pDb;




51,394,749✔





468



}










469












470



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




115,297,171✔





471



  SSdb *pSdb = pMnode->pSdb;




115,297,171✔





472



  sdbRelease(pSdb, pDb);




115,297,171✔





473



}




115,297,950✔





474












475



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




191,527✔





476



  SDbObj *pDb = mndAcquireDb(pMnode, db);




191,527✔





477



  if (pDb == NULL) {




191,527✔





478



    return false;




2,588✔





479



  } else {










480



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




188,939✔





481



    mndReleaseDb(pMnode, pDb);




188,939✔





482



    pDb = NULL;




188,939✔





483



    return result;




188,939✔





484



  }










485



}










486












487



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




1,382,958✔





488



  char *pos = strstr(dbName, TS_PATH_DELIMITER);




1,382,958✔





489



  if (pos == NULL) {




1,382,958✔





490



    return TSDB_CODE_MND_INVALID_DB;




×







491



  }










492












493



  int32_t acctId;




1,380,631✔





494



  int32_t code = taosStr2int32(dbName, &acctId);




1,382,958✔





495



  if (code != 0) {




1,382,958✔





496



    return code;




×







497



  }










498












499



  if (acctId != pUser->acctId) {




1,382,958✔





500



    return TSDB_CODE_MND_INVALID_DB_ACCT;




×







501



  }










502












503



  return 0;




1,382,958✔





504



}










505












506



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




1,382,958✔





507



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




1,382,958✔





508












509



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




1,382,958✔





510



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




1,382,958✔





511



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




1,382,958✔





512



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




1,382,958✔





513



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




1,382,958✔





514



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




1,382,958✔





515



  if (pCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




1,382,958✔





516



      pCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




1,381,396✔





517



    return code;




3,905✔





518



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




1,379,053✔





519



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




1,379,053✔





520



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




1,379,053✔





521



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




1,379,053✔





522



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




1,379,053✔





523



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




1,379,053✔





524



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




1,379,053✔





525



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




1,379,053✔





526



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




1,379,053✔





527



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




1,379,053✔





528



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




1,379,053✔





529



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




1,378,271✔





530



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




1,378,271✔





531



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




1,378,271✔





532



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




1,378,271✔





533



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




1,378,271✔





534



#ifdef TD_ENTERPRISE










535



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




1,378,271✔





536



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










537



#else










538



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










539



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










540



#endif










541












542



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




1,378,271✔





543



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




1,378,271✔





544



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




1,378,271✔





545



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




1,378,271✔





546



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




1,378,271✔





547



    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×







548



    TAOS_RETURN(code);




×







549



  }










550



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




1,378,271✔





551



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




1,378,271✔





552



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




1,378,271✔





553



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




1,378,271✔





554



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




1,378,271✔





555



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




1,378,271✔





556



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




1,378,271✔





557



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




1,378,271✔





558



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




1,378,271✔





559



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




1,378,271✔





560



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




1,378,271✔





561












562



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




1,378,271✔





563



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




1,378,271✔





564



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




1,378,271✔





565












566



  if (pCfg->compactInterval != 0 &&




1,378,271✔





567



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




3,994✔





568



    return code;




×







569



  if (pCfg->compactStartTime != 0 &&




1,378,271✔





570



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




4,415✔





571



    return code;




×







572



  if (pCfg->compactEndTime != 0 &&




1,378,271✔





573



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




4,415✔





574



    return code;




×







575



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




1,378,271✔





576



    return code;




×







577



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




1,378,271✔





578



    return code;




×







579



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




1,378,271✔





580



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










581












582



  code = 0;




1,378,271✔





583



  TAOS_RETURN(code);




1,378,271✔





584



}










585












586



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




92,528✔





587



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




92,528✔





588



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




92,528✔





589



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




92,528✔





590



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




92,528✔





591



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




92,528✔





592



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




92,528✔





593



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




92,528✔





594



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




92,528✔





595



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




92,528✔





596



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




92,528✔





597



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




92,528✔





598



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




92,528✔





599



    return code;




×







600



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




92,528✔





601



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




92,528✔





602



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




92,528✔





603



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




92,528✔





604



  if (pNewCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




92,528✔





605



      pNewCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




92,528✔





606



    return code;




×







607



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




92,528✔





608



#ifdef TD_ENTERPRISE










609



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




92,528✔





610



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




92,528✔





611



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




779✔





612



      terrno = TSDB_CODE_OPS_NOT_SUPPORT;




779✔





613



      return code;




779✔





614



    }










615



  }










616



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




91,749✔





617



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;




×







618



    return code;




×







619



  }










620



#else










621



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










622



#endif










623












624



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




91,749✔





625



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×







626



    return code;




×







627



  }










628



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




91,749✔





629



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×







630



    return code;




×







631



  }










632












633



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




91,749✔





634



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




1,358✔





635



    return code;




×







636



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




91,749✔





637



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




91,749✔





638



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




91,749✔





639



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




90,970✔





640



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




90,970✔





641



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




90,970✔





642



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




90,970✔





643



    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;




×







644



    return code;




×







645



  }










646



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




90,970✔





647



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




90,970✔





648



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




90,970✔





649












650



  if (pNewCfg->compactInterval != 0 &&




90,970✔





651



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




7,173✔





652



    return code;




×







653



  if (pNewCfg->compactStartTime != 0 &&




90,970✔





654



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




4,836✔





655



    return code;




×







656



  if (pNewCfg->compactEndTime != 0 &&




90,970✔





657



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




4,836✔





658



    return code;




×







659



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




90,970✔





660



      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)




4,836✔





661



    return code;




×







662



  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||




90,970✔





663



      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)




90,970✔





664



    return code;




×







665



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




90,970✔





666



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










667












668



  code = 0;




90,970✔





669



  TAOS_RETURN(code);




90,970✔





670



}










671












672



static void mndSetDefaultDbCfg(SDbCfg *pCfg) {




1,382,314✔





673



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




1,382,314✔





674



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




1,382,314✔





675



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




1,382,314✔





676



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




1,382,314✔





677



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




1,382,314✔





678



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




1,382,314✔





679



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




1,382,314✔





680



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




1,382,314✔





681



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




1,382,314✔





682



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




1,382,314✔





683



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




1,382,314✔





684



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




1,382,314✔





685



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




1,382,314✔





686



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




1,382,314✔





687



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




1,382,314✔





688



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




1,382,314✔





689



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




1,382,314✔





690



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




1,382,314✔





691



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




1,382,314✔





692



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




1,382,314✔





693



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




1,382,314✔





694



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




1,382,314✔





695



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




1,382,314✔





696



    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;




×







697



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




1,382,314✔





698



    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;




×







699



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




1,382,314✔





700



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




1,382,314✔





701



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




1,382,314✔





702



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




1,382,314✔





703



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




1,382,314✔





704



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




1,382,314✔





705



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




1,382,314✔





706



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




1,382,314✔





707



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




1,382,314✔





708



}




1,382,314✔





709












710



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




1,372,688✔





711



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,372,688✔





712



  if (pDbRaw == NULL) return -1;




1,372,688✔





713












714



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




1,372,688✔





715



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




1,372,688✔





716



  return 0;




1,372,688✔





717



}










718












719



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




1,372,044✔





720



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




4,293,652✔





721



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




2,921,608✔





722



  }










723



  return 0;




1,372,044✔





724



}










725












726



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




×







727



  int32_t  code = 0;




×







728



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




×







729



  if (pDbRaw == NULL) {




×







730



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







731



    if (terrno != 0) code = terrno;




×







732



    TAOS_RETURN(code);




×







733



  }










734



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));




×







735



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));




×







736












737



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




×







738



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




×







739



    if (pVgRaw == NULL) {




×







740



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







741



      if (terrno != 0) code = terrno;




×







742



      TAOS_RETURN(code);




×







743



    }










744



    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));




×







745



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));




×







746



  }










747












748



  if (pDb->cfg.withArbitrator) {




×







749



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




×







750



      SVgObj   *pVgObj = pVgroups + v;




×







751



      SArbGroup arbGroup = {0};




×







752



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




×







753



      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));




×







754



    }










755



  }










756












757



  TAOS_RETURN(code);




×







758



}










759












760



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




1,372,044✔





761



  int32_t  code = 0;




1,372,044✔





762



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,372,044✔





763



  if (pDbRaw == NULL) {




1,372,044✔





764



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







765



    if (terrno != 0) code = terrno;




×







766



    TAOS_RETURN(code);




×







767



  }










768



  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));




1,372,044✔





769



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));




1,372,044✔





770












771



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




4,293,652✔





772



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,921,608✔





773



    if (pVgRaw == NULL) {




2,921,608✔





774



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







775



      if (terrno != 0) code = terrno;




×







776



      TAOS_RETURN(code);




×







777



    }










778



    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));




2,921,608✔





779



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));




2,921,608✔





780



  }










781












782



  if (pDb->cfg.withArbitrator) {




1,372,044✔





783



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




11,043✔





784



      SVgObj   *pVgObj = pVgroups + v;




6,690✔





785



      SArbGroup arbGroup = {0};




6,690✔





786



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,690✔





787



      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));




6,690✔





788



    }










789



  }










790












791



  TAOS_RETURN(code);




1,372,044✔





792



}










793












794



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




1,372,044✔





795



                                        SUserObj *pUserDuped, SArray *pAuditOwnedDbs) {










796



  int32_t  code = 0;




1,372,044✔





797



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,372,044✔





798



  if (pDbRaw == NULL) {




1,372,044✔





799



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







800



    if (terrno != 0) code = terrno;




×







801



    TAOS_RETURN(code);




×







802



  }










803



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));




1,372,044✔





804



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));




1,372,044✔





805












806



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




4,293,652✔





807



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,921,608✔





808



    if (pVgRaw == NULL) {




2,921,608✔





809



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







810



      if (terrno != 0) code = terrno;




×







811



      TAOS_RETURN(code);




×







812



    }










813



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));




2,921,608✔





814



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));




2,921,608✔





815



  }










816












817



  if (pDb->cfg.withArbitrator) {




1,372,044✔





818



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




11,043✔





819



      SVgObj   *pVgObj = pVgroups + v;




6,690✔





820



      SArbGroup arbGroup = {0};




6,690✔





821



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,690✔





822



      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));




6,690✔





823



    }










824



  }










825












826



  if (pUserDuped) {




1,372,044✔





827



    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);




1,372,044✔





828



    if (pUserRaw == NULL) {




1,372,044✔





829



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







830



      if (terrno != 0) code = terrno;




×







831



      TAOS_RETURN(code);




×







832



    }










833



    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));




1,372,044✔





834



    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));




1,372,044✔





835



  }










836












837



  if(pAuditOwnedDbs) {




1,372,044✔





838



    int32_t auditOwnedDbSize = taosArrayGetSize(pAuditOwnedDbs);




×







839



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




×







840



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




×







841



      SSdbRaw  *pAuditUserRaw = mndUserActionEncode(pAuditUser);




×







842



      if (pAuditUserRaw == NULL) {




×







843



        TAOS_RETURN(terrno ? terrno : TSDB_CODE_MND_RETURN_VALUE_NULL);




×







844



      }










845



      TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pAuditUserRaw));




×







846



      TAOS_CHECK_RETURN(sdbSetRawStatus(pAuditUserRaw, SDB_STATUS_READY));




×







847



    }










848



  }










849












850



  TAOS_RETURN(code);




1,372,044✔





851



}










852












853



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




1,372,044✔





854



  int32_t code = 0;




1,372,044✔





855



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




4,293,652✔





856



    SVgObj *pVgroup = pVgroups + vg;




2,921,608✔





857












858



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




6,135,672✔





859



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




3,214,064✔





860



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




3,214,064✔





861



    }










862



  }










863












864



  TAOS_RETURN(code);




1,372,044✔





865



}










866












867



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




1,372,044✔





868



  int32_t code = 0;




1,372,044✔





869



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




4,293,652✔





870



    SVgObj *pVgroup = pVgroups + vg;




2,921,608✔





871












872



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




6,135,672✔





873



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




3,214,064✔





874



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




3,214,064✔





875



    }










876



  }










877












878



  TAOS_RETURN(code);




1,372,044✔





879



}










880












881



/**










882



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










883



 *










884



 * @param pMnode










885



 * @param pOperUser










886



 * @param pDb










887



 * @param pAuditOwnedDbs










888



 * @return int32_t










889



 */










890



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




334✔





891



  int32_t   code = 0, lino = 0;




334✔





892



  SSdb     *pSdb = pMnode->pSdb;




334✔





893



  SArray   *auditOwnedDbs = NULL;




334✔





894



  SUserObj *pUser = NULL;




334✔





895



  SUserObj  newUserObj = {0};




334✔





896



  int32_t   sysAuditLen = strlen(TSDB_ROLE_SYSAUDIT) + 1;




334✔





897



  int32_t   sysAuditLogLen = strlen(TSDB_ROLE_SYSAUDIT_LOG) + 1;




334✔





898












899



  void *pIter = NULL;




334✔





900



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




668✔





901



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




334✔





902



      sdbRelease(pSdb, pUser);




×







903



      pUser = NULL;




×







904



      continue;




×







905



    }










906



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




334✔





907



      sdbRelease(pSdb, pUser);




334✔





908



      pUser = NULL;




334✔





909



      continue;




334✔





910



    }










911



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




×







912



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




×







913



      sdbRelease(pSdb, pUser);




×







914



      pUser = NULL;




×







915



      continue;




×







916



    }










917



    TAOS_CHECK_EXIT(mndUserDupObj(pUser, &newUserObj));




×







918



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




×







919



    if (auditOwnedDbs == NULL) {




×







920



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




×







921



      if (auditOwnedDbs == NULL) {




×







922



        TAOS_CHECK_EXIT(terrno);




×







923



      }










924



    }










925



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




×







926



      TAOS_CHECK_EXIT(terrno);




×







927



    }










928



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




×







929



    sdbRelease(pSdb, pUser);




×







930



    pUser = NULL;




×







931



  }










932



  *pAuditOwnedDbs = auditOwnedDbs;




334✔





933



  auditOwnedDbs = NULL;




334✔





934



_exit:




334✔





935



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




334✔





936



  sdbRelease(pSdb, pUser);




334✔





937



  sdbCancelFetch(pSdb, pIter);




334✔





938



  mndUserFreeObj(&newUserObj);




334✔





939



  TAOS_RETURN(code);




334✔





940



}










941












942



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




1,384,690✔





943



  int32_t  code = 0;




1,384,690✔





944



  SArray  *auditOwnedDbs = NULL;




1,384,690✔





945



  SUserObj newUserObj = {0};




1,384,690✔





946



  SDbObj   dbObj = {0};




1,384,690✔





947



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




1,384,690✔





948



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




1,384,690✔





949



  dbObj.createdTime = taosGetTimestampMs();




1,384,690✔





950



  dbObj.updateTime = dbObj.createdTime;




1,384,690✔





951



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




1,384,690✔





952



  dbObj.cfgVersion = 1;




1,384,690✔





953



  dbObj.vgVersion = 1;




1,384,690✔





954



  dbObj.tsmaVersion = 1;




1,384,690✔





955



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




1,384,690✔





956



  dbObj.ownerId = pUser->uid;




1,384,690✔





957



  dbObj.cfg = (SDbCfg){




2,767,053✔





958



      .numOfVgroups = pCreate->numOfVgroups,




1,384,690✔





959



      .numOfStables = pCreate->numOfStables,




1,384,690✔





960



      .buffer = pCreate->buffer,




1,384,690✔





961



      .pageSize = pCreate->pageSize,




1,384,690✔





962



      .pages = pCreate->pages,




1,384,690✔





963



      .cacheLastSize = pCreate->cacheLastSize,




1,384,690✔





964



      .cacheLastShardBits = pCreate->cacheLastShardBits,




1,384,690✔





965



      .daysPerFile = pCreate->daysPerFile,




1,384,690✔





966



      .daysToKeep0 = pCreate->daysToKeep0,




1,384,690✔





967



      .daysToKeep1 = pCreate->daysToKeep1,




1,384,690✔





968



      .daysToKeep2 = pCreate->daysToKeep2,




1,384,690✔





969



      .keepTimeOffset = pCreate->keepTimeOffset,




1,384,690✔





970



      .minRows = pCreate->minRows,




1,384,690✔





971



      .maxRows = pCreate->maxRows,




1,384,690✔





972



      .walFsyncPeriod = pCreate->walFsyncPeriod,




1,384,690✔





973



      .walLevel = pCreate->walLevel,




1,384,690✔





974



      .precision = pCreate->precision,




1,384,690✔





975



      .compression = pCreate->compression,




1,384,690✔





976



      .replications = pCreate->replications,




1,384,690✔





977



      .strict = pCreate->strict,




1,384,690✔





978



      .cacheLast = pCreate->cacheLast,




1,384,690✔





979



      .hashMethod = 1,










980



      .schemaless = pCreate->schemaless,




1,384,690✔





981



      .walRetentionPeriod = pCreate->walRetentionPeriod,




1,384,690✔





982



      .walRetentionSize = pCreate->walRetentionSize,




1,384,690✔





983



      .walRollPeriod = pCreate->walRollPeriod,




1,384,690✔





984



      .walSegmentSize = pCreate->walSegmentSize,




1,384,690✔





985



      .sstTrigger = pCreate->sstTrigger,




1,384,690✔





986



      .hashPrefix = pCreate->hashPrefix,




1,384,690✔





987



      .hashSuffix = pCreate->hashSuffix,




1,384,690✔





988



      .ssChunkSize = pCreate->ssChunkSize,




1,384,690✔





989



      .ssKeepLocal = pCreate->ssKeepLocal,




1,384,690✔





990



      .ssCompact = pCreate->ssCompact,




1,384,690✔





991



      .tsdbPageSize = pCreate->tsdbPageSize,




1,384,690✔





992



      .withArbitrator = pCreate->withArbitrator,




1,384,690✔





993



      .encryptAlgorithm = pCreate->encryptAlgorithm,




1,384,690✔





994



      .compactInterval = pCreate->compactInterval,




1,384,690✔





995



      .compactStartTime = pCreate->compactStartTime,




1,384,690✔





996



      .compactEndTime = pCreate->compactEndTime,




1,384,690✔





997



      .compactTimeOffset = pCreate->compactTimeOffset,




1,384,690✔





998



      .isAudit = pCreate->isAudit,




1,384,690✔





999



      .secureDelete = pCreate->secureDelete,




1,384,690✔





1000



  };










1001



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




1,384,690✔





1002



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




7,336✔





1003



      if (pCreate->isAudit == 1) {




3,803✔





1004



        code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




×







1005



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




×







1006



               pCreate->encryptAlgrName);










1007



        TAOS_RETURN(code);




×







1008



      }










1009



      dbObj.cfg.encryptAlgorithm = 0;




3,803✔





1010



    } else {










1011



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




3,533✔





1012



      if (pEncryptAlgr != NULL) {




3,533✔





1013



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




2,727✔





1014



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×







1015



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




×







1016



                 pCreate->encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);










1017



          TAOS_RETURN(code);




×







1018



        }










1019



        dbObj.cfg.encryptAlgorithm = pEncryptAlgr->id;




2,727✔





1020



      } else {










1021



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




806✔





1022



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




806✔





1023



        TAOS_RETURN(code);




806✔





1024



      }










1025



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




2,727✔





1026



        code = TSDB_CODE_DNODE_INVALID_ENCRYPTKEY;




×







1027



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




×







1028



        TAOS_RETURN(code);




×







1029



      }










1030



    }










1031



  } else {










1032



    if (pCreate->isAudit == 1) {




1,377,354✔





1033



      code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




1,570✔





1034



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




1,570✔





1035



             pCreate->encryptAlgrName);










1036



      TAOS_RETURN(code);




1,570✔





1037



    }










1038



  }










1039



  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;




1,382,314✔





1040



  dbObj.cfg.pRetensions = pCreate->pRetensions;




1,382,314✔





1041












1042



  if (pCreate->isAudit == 1) {




1,382,314✔





1043



    if (dbObj.cfg.daysToKeep2 < 2628000) {




334✔





1044



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×







1045



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




×







1046



      TAOS_RETURN(code);




×







1047



    }










1048



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




334✔





1049



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×







1050



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




×







1051



      TAOS_RETURN(code);




×







1052



    }










1053



    dbObj.cfg.allowDrop = TSDB_MIN_DB_ALLOW_DROP;




334✔





1054



  } else {










1055



    dbObj.cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




1,381,980✔





1056



  }










1057












1058



  mndSetDefaultDbCfg(&dbObj.cfg);




1,382,314✔





1059












1060



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




1,382,314✔





1061



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




×







1062



    TAOS_RETURN(code);




×







1063



  }










1064












1065



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




1,382,314✔





1066



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




4,687✔





1067



    TAOS_RETURN(code);




4,687✔





1068



  }










1069












1070



  if (dbObj.cfg.hashPrefix > 0) {




1,377,627✔





1071



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




5,016✔





1072



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




5,016✔





1073



    dbObj.cfg.hashPrefix += dbLen;




5,016✔





1074



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




1,372,611✔





1075



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




5,118✔





1076



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




5,118✔





1077



    dbObj.cfg.hashPrefix -= dbLen;




5,118✔





1078



  }










1079












1080



  SVgObj *pVgroups = NULL;




1,377,627✔





1081



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




1,377,627✔





1082



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




5,583✔





1083



    TAOS_RETURN(code);




5,583✔





1084



  }










1085












1086



  // add database privileges for user










1087



  SUserObj *pNewUserDuped = NULL;




1,372,044✔





1088



#if 0










1089



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










1090



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










1091



  if (!pUser->superUser) {










1092



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










1093



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










1094



                    NULL, _OVER);










1095



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










1096



                    NULL, _OVER);










1097



    pNewUserDuped = &newUserObj;










1098



  }










1099



#else










1100



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










1101



  bool addOwned = false;




1,372,044✔





1102



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




1,372,044✔





1103



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




334✔





1104



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




×







1105



      addOwned = true;




334✔





1106



    }










1107



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




334✔





1108



  } else {










1109



    addOwned = true;




1,371,710✔





1110



  }










1111



  if (addOwned) {




1,372,044✔





1112



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




1,372,044✔





1113



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




1,372,044✔





1114



    pNewUserDuped = &newUserObj;




1,372,044✔





1115



  }










1116



#endif










1117












1118



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




1,372,044✔





1119



  if (pTrans == NULL) {




1,372,044✔





1120



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1121



    if (terrno != 0) code = terrno;




×







1122



    goto _OVER;




×







1123



  }










1124



  // mndTransSetSerial(pTrans);










1125



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




1,372,044✔





1126












1127



  mndTransSetDbName(pTrans, dbObj.name, NULL);




1,372,044✔





1128



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




1,372,044✔





1129












1130



  void   *pIter = NULL;




1,372,044✔





1131



  STrans *exitTrans = NULL;




1,372,044✔





1132












1133



  if (!pUser->superUser) {




1,372,044✔





1134



    while (1) {










1135



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




3,917✔





1136



      if (pIter == NULL) break;




3,917✔





1137












1138



      if (exitTrans->conflict == TRN_CONFLICT_DB &&




×







1139



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




×







1140



        code = TSDB_CODE_MND_TRANS_CONFLICT;




×







1141



        sdbRelease(pMnode->pSdb, exitTrans);




×







1142



        sdbCancelFetch(pMnode->pSdb, pIter);




×







1143



        goto _OVER;




×







1144



      }










1145












1146



      sdbRelease(pMnode->pSdb, exitTrans);




×







1147



    }










1148



  }










1149












1150



  if (dbObj.cfg.isAudit) {




1,372,044✔





1151



    if (dbObj.cfg.numOfVgroups > 1) {




334✔





1152



      code = TSDB_CODE_AUDIT_DB_NOT_MULTI_VGROUP;




×







1153



      TAOS_CHECK_GOTO(code, NULL, _OVER);




×







1154



    }










1155



  }










1156












1157



  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);




1,372,044✔





1158



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




1,372,044✔





1159



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




1,372,044✔





1160



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




1,372,044✔





1161



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




1,372,044✔





1162



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




1,372,044✔





1163



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




1,372,044✔





1164












1165



  if (dbObj.cfg.isAudit) {




1,372,044✔





1166



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










1167



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




334✔





1168



  }










1169



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




1,372,044✔





1170












1171



_OVER:




1,372,044✔





1172



  taosMemoryFree(pVgroups);




1,372,044✔





1173



  mndUserFreeObj(&newUserObj);




1,372,044✔





1174



  taosArrayDestroyEx(auditOwnedDbs, (FDelete)mndUserFreeObj);




1,372,044✔





1175



  mndTransDrop(pTrans);




1,372,044✔





1176



  TAOS_RETURN(code);




1,372,044✔





1177



}










1178












1179



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




1,397,154✔





1180



  int32_t    code = 0;




1,397,154✔





1181



  SSdb      *pSdb = pMnode->pSdb;




1,397,154✔





1182



  SDnodeObj *pDnode = NULL;




1,397,154✔





1183



  void      *pIter = NULL;




1,397,154✔





1184












1185



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










1186



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




1,397,154✔





1187



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




×







1188



  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {




×







1189



    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1190



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




×







1191



           tsEncryptionKeyStat);










1192



    goto _exit;




×







1193



  }










1194












1195



  int64_t curMs = taosGetTimestampMs();




×







1196



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




×







1197



    bool online = false;




×







1198



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




×







1199



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




×







1200



      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1201



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




×







1202



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










1203



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










1204



             tsEncryptionKeyChksum);










1205



      sdbCancelFetch(pSdb, pIter);




×







1206



      sdbRelease(pSdb, pDnode);




×







1207



      break;




×







1208



    }










1209



    sdbRelease(pSdb, pDnode);




×







1210



  }










1211



#else










1212



  if (pReq->encryptAlgorithm != TSDB_ENCRYPT_ALGO_NONE) {










1213



    code = TSDB_CODE_MND_INVALID_DB_OPTION;










1214



    goto _exit;










1215



  }










1216



#endif










1217



_exit:




1,394,827✔





1218



  TAOS_RETURN(code);




1,397,154✔





1219



}










1220












1221



#ifndef TD_ENTERPRISE










1222



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










1223



  if (dnodeListStr[0] != 0) {










1224



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;










1225



    return terrno;










1226



  } else {










1227



    return 0;










1228



  }










1229



}










1230



#endif










1231












1232



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {




1,511,700✔





1233



  SMnode      *pMnode = pReq->info.node;




1,511,700✔





1234



  int32_t      code = -1;




1,511,700✔





1235



  int32_t      lino = 0;




1,511,700✔





1236



  SDbObj      *pDb = NULL;




1,511,700✔





1237



  SUserObj    *pUser = NULL;




1,511,700✔





1238



  SCreateDbReq createReq = {0};




1,511,700✔





1239



  SArray      *dnodeList = NULL;




1,511,700✔





1240



  int64_t      tss = taosGetTimestampMs();




1,511,700✔





1241












1242



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




1,511,700✔





1243



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




1,511,700✔





1244












1245



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




1,511,700✔





1246



#ifdef WINDOWS










1247



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










1248



    terrno = TSDB_CODE_MND_INVALID_PLATFORM;










1249



    goto _OVER;










1250



  }










1251



#endif










1252



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




1,511,700✔





1253












1254



  pDb = mndAcquireDb(pMnode, createReq.db);




1,511,700✔





1255



  if (pDb != NULL) {




1,511,700✔





1256



    if (createReq.ignoreExist) {




104,608✔





1257



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




102,092✔





1258



      code = 0;




102,092✔





1259



      goto _OVER;




102,092✔





1260



    } else {










1261



      code = TSDB_CODE_MND_DB_ALREADY_EXIST;




2,516✔





1262



      goto _OVER;




2,516✔





1263



    }










1264



  } else {










1265



    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {




1,407,092✔





1266



      code = terrno;




9,581✔





1267



      goto _OVER;




9,581✔





1268



    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {




1,397,511✔





1269



      goto _OVER;




×







1270



    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {




1,397,511✔





1271



      // continue










1272



    } else {  // TSDB_CODE_APP_ERROR










1273



      goto _OVER;




×







1274



    }










1275



  }










1276












1277



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




1,397,511✔





1278












1279



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




1,397,154✔





1280












1281



  int32_t nVnodes = createReq.numOfVgroups * createReq.replications;




1,397,154✔





1282



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




1,397,154✔





1283












1284



  if (createReq.replications == 2) {




1,397,154✔





1285



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




5,911✔





1286



  }










1287












1288



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




1,397,154✔





1289












1290



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




1,397,154✔





1291












1292



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




1,384,690✔





1293












1294



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




1,384,690✔





1295



    TAOS_CHECK_GOTO(TSDB_CODE_MND_MOUNT_NOT_EMPTY, &lino, _OVER);




×







1296



  }










1297












1298



  if (createReq.isAudit == 1) {




1,384,690✔





1299



    SDbObj *pAuditDb = mndAcquireAuditDb(pMnode);




1,904✔





1300



    if (pAuditDb != NULL) {




1,904✔





1301



      mndReleaseDb(pMnode, pAuditDb);




×







1302



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




×







1303



      TAOS_CHECK_GOTO(TSDB_CODE_AUDIT_DB_ALREADY_EXIST, &lino, _OVER);




×







1304



    }










1305



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




1,904✔





1306



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




1,904✔





1307



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




×







1308



      TAOS_CHECK_GOTO(TSDB_CODE_MND_INVALID_DB, &lino, _OVER);




×







1309



    }










1310



  }










1311












1312



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




1,384,690✔





1313



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




1,372,044✔





1314












1315



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




1,372,044✔





1316



    SName name = {0};




1,372,044✔





1317



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




1,372,044✔





1318



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




×







1319



    int64_t tse = taosGetTimestampMs();




1,372,044✔





1320



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




1,372,044✔





1321



    duration = duration / 1000;




1,372,044✔





1322



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




1,372,044✔





1323



  }










1324












1325



_OVER:




1,509,373✔





1326



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




1,511,700✔





1327



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




37,564✔





1328



  }










1329












1330



  mndReleaseDb(pMnode, pDb);




1,511,700✔





1331



  mndReleaseUser(pMnode, pUser);




1,511,700✔





1332



  tFreeSCreateDbReq(&createReq);




1,511,700✔





1333



  taosArrayDestroy(dnodeList);




1,511,700✔





1334












1335



  TAOS_RETURN(code);




1,511,700✔





1336



}










1337












1338



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




119,332✔





1339



  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;




119,332✔





1340












1341



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




119,332✔





1342



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




948✔





1343



    code = 0;




948✔





1344



  }










1345












1346



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




119,332✔





1347



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




2,418✔





1348



    code = 0;




2,418✔





1349



  }










1350












1351



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




119,332✔





1352



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




×







1353



    code = 0;




×







1354



  }










1355












1356



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




119,332✔





1357



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




×







1358



    code = 0;




×







1359



  }










1360












1361



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




119,332✔





1362



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




17,138✔





1363



    code = 0;




17,138✔





1364



  }










1365












1366



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




119,332✔





1367



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




16,359✔





1368



    code = 0;




16,359✔





1369



  }










1370












1371



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




119,332✔





1372



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




13,294✔





1373



    code = 0;




13,294✔





1374



  }










1375












1376



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




119,332✔





1377



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




3,922✔





1378



    code = 0;




3,922✔





1379



  }










1380












1381



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




119,332✔





1382



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




9,372✔





1383



    code = 0;




9,372✔





1384



  }










1385












1386



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




119,332✔





1387



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




9,369✔





1388



    code = 0;




9,369✔





1389



  }










1390












1391



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




119,332✔





1392



#if 1










1393



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1394



#else










1395



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










1396



    code = 0;










1397



#endif










1398



  }










1399












1400



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




119,332✔





1401



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




16,292✔





1402



    code = 0;




16,292✔





1403



  }










1404












1405



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




119,332✔





1406



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




2,536✔





1407



    code = 0;




2,536✔





1408



  }










1409












1410



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




119,332✔





1411



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




781✔





1412



    code = 0;




781✔





1413



  }










1414












1415



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




119,332✔





1416



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




7,081✔





1417



    pDb->vgVersion++;




7,081✔





1418



    code = 0;




7,081✔





1419



  }










1420












1421



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




119,332✔





1422



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




1,358✔





1423



    pDb->vgVersion++;




1,358✔





1424



    code = 0;




1,358✔





1425



  }










1426












1427



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




119,332✔





1428



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




1,558✔





1429



    pDb->vgVersion++;




1,558✔





1430



    code = 0;




1,558✔





1431



  }










1432












1433



  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&




119,332✔





1434



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




13,738✔





1435



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




7,761✔





1436



    pDb->vgVersion++;




7,761✔





1437



    code = 0;




7,761✔





1438



  }










1439












1440



  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&




119,332✔





1441



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




1,585✔





1442



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




779✔





1443



    pDb->vgVersion++;




779✔





1444



    code = 0;




779✔





1445



  }










1446












1447



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




119,332✔





1448



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




779✔





1449



    pDb->vgVersion++;




779✔





1450



    code = 0;




779✔





1451



  }










1452












1453



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




119,332✔





1454



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




779✔





1455



    pDb->vgVersion++;




779✔





1456



    code = 0;




779✔





1457



  }










1458












1459



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




119,332✔





1460



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




779✔





1461



    pDb->vgVersion++;




779✔





1462



    code = 0;




779✔





1463



  }










1464












1465



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




119,332✔





1466



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




5,588✔





1467



    pDb->vgVersion++;




5,588✔





1468



    code = 0;




5,588✔





1469



  }










1470












1471



  bool compactTimeRangeChanged = false;




119,332✔





1472



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




119,332✔





1473



      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||




116,914✔





1474



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




116,914✔





1475



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




4,836✔





1476



    compactTimeRangeChanged = true;




4,836✔





1477



    code = 0;




4,836✔





1478



  }










1479












1480



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




119,332✔





1481



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




116,914✔





1482



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




4,836✔





1483



    compactTimeRangeChanged = true;




4,836✔





1484



    code = 0;




4,836✔





1485



  }










1486



  if(compactTimeRangeChanged) {




119,332✔





1487



    pDb->vgVersion++;




4,836✔





1488



  }










1489












1490



  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&




119,332✔





1491



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




9,645✔





1492



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




4,003✔





1493



    pDb->vgVersion++;




4,003✔





1494



    code = 0;




4,003✔





1495



  }










1496












1497



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




119,332✔





1498



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1499



    return code;




×







1500



  }










1501












1502



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




119,332✔





1503



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




×







1504



    code = 0;




×







1505



  }










1506












1507



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




119,332✔





1508



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




613✔





1509



    pDb->vgVersion++;




613✔





1510



    code = 0;




613✔





1511



  }










1512












1513



  TAOS_RETURN(code);




119,332✔





1514



}










1515












1516



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




90,024✔





1517



  int32_t  code = 0;




90,024✔





1518



  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);




90,024✔





1519



  if (pRedoRaw == NULL) {




90,024✔





1520



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1521



    if (terrno != 0) code = terrno;




×







1522



    TAOS_RETURN(code);




×







1523



  }










1524



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




90,024✔





1525



    sdbFreeRaw(pRedoRaw);




×







1526



    TAOS_RETURN(code);




×







1527



  }










1528












1529



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




90,024✔





1530



    sdbFreeRaw(pRedoRaw);




×







1531



    TAOS_RETURN(code);




×







1532



  }










1533



  return 0;




90,024✔





1534



}










1535












1536



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




90,024✔





1537



  int32_t  code = 0;




90,024✔





1538



  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);




90,024✔





1539



  if (pCommitRaw == NULL) {




90,024✔





1540



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1541



    if (terrno != 0) code = terrno;




×







1542



    TAOS_RETURN(code);




×







1543



  }










1544



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




90,024✔





1545



    sdbFreeRaw(pCommitRaw);




×







1546



    TAOS_RETURN(code);




×







1547



  }










1548












1549



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




90,024✔





1550



    sdbFreeRaw(pCommitRaw);




×







1551



    TAOS_RETURN(code);




×







1552



  }










1553



  TAOS_RETURN(code);




90,024✔





1554



}










1555












1556



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




90,024✔





1557



  int32_t code = 0, lino = 0;




90,024✔





1558



  SSdb   *pSdb = pMnode->pSdb;




90,024✔





1559



  void   *pIter = NULL;




90,024✔





1560



  SVgObj *pVgroup = NULL;




90,024✔





1561



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




90,024✔





1562












1563



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




90,024✔





1564












1565



  while (1) {










1566



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




644,451✔





1567



    if (pIter == NULL) break;




644,451✔





1568












1569



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




555,186✔





1570



      SVgObj newVgroup = {0};




235,933✔





1571



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




235,933✔





1572



                      _err);










1573












1574



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




235,174✔





1575



        if (pNewDb->cfg.withArbitrator) {




×







1576



          SArbGroup arbGroup = {0};




×







1577



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




×







1578



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




×







1579



        } else {










1580



          SArbGroup arbGroup = {0};




×







1581



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




×







1582



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




×







1583



        }










1584



      }










1585



    }










1586












1587



    sdbRelease(pSdb, pVgroup);




554,427✔





1588



  }










1589












1590



  taosArrayDestroy(pArray);




89,265✔





1591



  TAOS_RETURN(code);




89,265✔





1592












1593



_err:




759✔





1594



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




759✔





1595












1596



  sdbCancelFetch(pSdb, pIter);




759✔





1597



  sdbRelease(pSdb, pVgroup);




759✔





1598



  taosArrayDestroy(pArray);




759✔





1599



  TAOS_RETURN(code);




759✔





1600



}










1601












1602



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




90,970✔





1603



  int32_t code = -1;




90,970✔





1604



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




90,970✔





1605



  if (pTrans == NULL) {




90,970✔





1606



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1607



    if (terrno != 0) code = terrno;




×







1608



    TAOS_RETURN(code);




×







1609



  }










1610



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




90,970✔





1611



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




90,970✔





1612












1613



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




90,970✔





1614



  mndTransSetGroupParallel(pTrans);




90,970✔





1615



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




90,970✔





1616



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




90,110✔





1617



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




90,024✔





1618












1619



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




90,024✔





1620



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




90,024✔





1621



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




90,024✔





1622












1623



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




89,265✔





1624



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




89,265✔





1625



  code = 0;




89,265✔





1626












1627



_OVER:




90,970✔





1628



  mndTransDrop(pTrans);




90,970✔





1629



  TAOS_RETURN(code);




90,970✔





1630



}










1631












1632



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {




123,050✔





1633



  SMnode     *pMnode = pReq->info.node;




123,050✔





1634



  int32_t     code = -1;




123,050✔





1635



  SDbObj     *pDb = NULL;




123,050✔





1636



  SAlterDbReq alterReq = {0};




123,050✔





1637



  SDbObj      dbObj = {0};




123,050✔





1638



  int64_t     tss = taosGetTimestampMs();




123,050✔





1639












1640



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




123,050✔





1641












1642



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




123,050✔





1643












1644



  pDb = mndAcquireDb(pMnode, alterReq.db);




123,050✔





1645



  if (pDb == NULL) {




123,050✔





1646



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




1,170✔





1647



    if (terrno != 0) code = terrno;




1,170✔





1648



    goto _OVER;




1,170✔





1649



  }










1650












1651



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




121,880✔





1652












1653



  if (alterReq.replications == 2) {




121,723✔





1654



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




779✔





1655



  }










1656












1657



  int32_t numOfTopics = 0;




121,723✔





1658



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




121,723✔





1659












1660



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




121,723✔





1661



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×







1662



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




×







1663



           numOfTopics);










1664



    goto _OVER;




×







1665



  }










1666












1667



  if (pDb->cfg.isMount) {




121,723✔





1668



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×







1669



    goto _OVER;




×







1670



  }










1671












1672



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




121,723✔





1673



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




121,723✔





1674



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




×







1675



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




×







1676



  }










1677












1678



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




121,723✔





1679



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




×







1680



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×







1681



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




×







1682



      goto _OVER;




×







1683



    }










1684



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




×







1685



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×







1686



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




×







1687



      goto _OVER;




×







1688



    }










1689



    if (alterReq.isAudit == 0) {




×







1690



      code = TSDB_CODE_AUDIT_DB_NOT_ALLOW_CHANGE;




×







1691



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




×







1692



      goto _OVER;




×







1693



    }










1694



  }










1695












1696



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




121,723✔





1697



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




3,197✔





1698












1699



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




3,197✔





1700



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




806✔





1701



        code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




×







1702



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




×







1703



        goto _OVER;




×







1704



      }










1705



    } else {










1706



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




2,391✔





1707



      if (pEncryptAlgr != NULL) {




2,391✔





1708



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




1,585✔





1709



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×







1710



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




×







1711



                 alterReq.encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);










1712



          goto _OVER;




×







1713



        }










1714



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




1,585✔





1715



          code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




1,585✔





1716



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




1,585✔





1717



          goto _OVER;




1,585✔





1718



        }










1719



      } else {










1720



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




806✔





1721



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




806✔





1722



        goto _OVER;




806✔





1723



      }










1724



    }










1725



  }










1726












1727



  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);




119,332✔





1728



  if (code != 0) {




119,332✔





1729



    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;




26,804✔





1730



    goto _OVER;




26,804✔





1731



  }










1732












1733



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




92,528✔





1734












1735



  dbObj.cfgVersion++;




90,970✔





1736



  dbObj.updateTime = taosGetTimestampMs();




90,970✔





1737



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




90,970✔





1738












1739



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




90,970✔





1740



    // return quickly, operation executed asynchronously










1741



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




6,302✔





1742



  } else {










1743



    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




84,668✔





1744



  }










1745












1746



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




90,970✔





1747



    SName name = {0};




90,970✔





1748



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




90,970✔





1749



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




×







1750












1751



    int64_t tse = taosGetTimestampMs();




90,970✔





1752



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




90,970✔





1753



    duration = duration / 1000;




90,970✔





1754



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




90,970✔





1755



  }










1756












1757



_OVER:




123,050✔





1758



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




123,050✔





1759



    if (terrno != 0) code = terrno;




6,981✔





1760



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




6,981✔





1761



  }










1762












1763



  mndReleaseDb(pMnode, pDb);




123,050✔





1764



  taosArrayDestroy(dbObj.cfg.pRetensions);




123,050✔





1765



  tFreeSAlterDbReq(&alterReq);




123,050✔





1766












1767



  TAOS_RETURN(code);




123,050✔





1768



}










1769












1770



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




4,354,087✔





1771



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




4,354,087✔





1772



  cfgRsp->dbId = pDb->uid;




4,354,085✔





1773



  cfgRsp->ownerId = pDb->ownerId;




4,354,087✔





1774



  cfgRsp->cfgVersion = pDb->cfgVersion;




4,354,087✔





1775



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




4,354,085✔





1776



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




4,354,087✔





1777



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




4,354,085✔





1778



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




4,354,087✔





1779



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




4,354,085✔





1780



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




4,354,085✔





1781



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




4,354,085✔





1782



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




4,354,087✔





1783



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




4,354,085✔





1784



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




4,354,087✔





1785



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




4,354,085✔





1786



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




4,354,087✔





1787



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




4,354,085✔





1788



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




4,354,087✔





1789



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




4,354,087✔





1790



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




4,354,087✔





1791



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




4,354,087✔





1792



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




4,354,087✔





1793



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




4,354,087✔





1794



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




4,354,087✔





1795



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




4,354,085✔





1796



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




4,354,087✔





1797



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




4,354,085✔





1798



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




4,354,085✔





1799



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




4,354,087✔





1800



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




4,354,087✔





1801



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




4,354,085✔





1802



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




4,354,087✔





1803



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




4,354,087✔





1804



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




4,354,087✔





1805



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




4,354,085✔





1806



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




4,354,087✔





1807



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




4,354,085✔





1808



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




4,354,085✔





1809



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




4,354,085✔





1810



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




4,354,085✔





1811



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




4,354,087✔





1812



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










1813



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




4,354,087✔





1814



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




4,354,087✔





1815



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




4,354,087✔





1816



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




4,354,087✔





1817



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




4,354,085✔





1818



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




4,354,087✔





1819



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




4,354,087✔





1820



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




4,354,087✔





1821



}




4,354,085✔





1822












1823



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {




5,312,323✔





1824



  SMnode   *pMnode = pReq->info.node;




5,312,323✔





1825



  int32_t   code = -1;




5,312,323✔





1826



  SDbObj   *pDb = NULL;




5,312,323✔





1827



  SDbCfgReq cfgReq = {0};




5,312,323✔





1828



  SDbCfgRsp cfgRsp = {0};




5,312,323✔





1829












1830



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




5,312,321✔





1831












1832



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




5,312,323✔





1833



  if (pRealDb) {




5,312,323✔





1834



    ++pRealDb;




5,312,323✔





1835



  } else {










1836



    pRealDb = &cfgReq.db[0];




×







1837



  }










1838



  if (!IS_SYS_DBNAME(pRealDb)) {




5,312,323✔





1839



    pDb = mndAcquireDb(pMnode, cfgReq.db);




4,848,444✔





1840



    if (pDb == NULL) {




4,848,444✔





1841



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




580,894✔





1842



      if (terrno != 0) code = terrno;




580,894✔





1843



      goto _OVER;




580,894✔





1844



    }










1845












1846



    char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




4,267,550✔





1847



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




4,267,550✔





1848



    mndDumpDbCfgInfo(&cfgRsp, pDb, algrId);




4,267,550✔





1849



  }










1850












1851



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




4,731,427✔





1852



  void   *pRsp = rpcMallocCont(contLen);




4,731,429✔





1853



  if (pRsp == NULL) {




4,731,427✔





1854



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1855



    if (terrno != 0) code = terrno;




×







1856



    goto _OVER;




×







1857



  }










1858












1859



  int32_t ret = 0;




4,731,427✔





1860



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




4,731,427✔





1861



    code = ret;




×







1862



    goto _OVER;




×







1863



  }










1864












1865



  pReq->info.rsp = pRsp;




4,731,429✔





1866



  pReq->info.rspLen = contLen;




4,731,429✔





1867












1868



  code = 0;




4,731,429✔





1869












1870



_OVER:




5,312,325✔





1871












1872



  tFreeSDbCfgRsp(&cfgRsp);




5,310,765✔





1873












1874



  if (code != 0) {




5,311,542✔





1875



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




580,894✔





1876



  }










1877












1878



  mndReleaseDb(pMnode, pDb);




5,311,542✔





1879












1880



  TAOS_RETURN(code);




5,312,323✔





1881



}










1882












1883



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




748,707✔





1884



  int32_t  code = 0;




748,707✔





1885



  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);




748,707✔





1886



  if (pRedoRaw == NULL) {




748,707✔





1887



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1888



    if (terrno != 0) code = terrno;




×







1889



    return -1;




×







1890



  }










1891



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));




748,707✔





1892



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));




748,707✔





1893












1894



  SSdb *pSdb = pMnode->pSdb;




748,707✔





1895



  void *pIter = NULL;




748,707✔





1896












1897



  while (1) {




4,674✔





1898



    SArbGroup *pArbGroup = NULL;




753,381✔





1899



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




753,381✔





1900



    if (pIter == NULL) break;




753,381✔





1901












1902



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




4,674✔





1903



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




4,674✔





1904



        sdbCancelFetch(pSdb, pIter);




×







1905



        sdbRelease(pSdb, pArbGroup);




×







1906



        TAOS_RETURN(code);




×







1907



      }










1908



    }










1909












1910



    sdbRelease(pSdb, pArbGroup);




4,674✔





1911



  }










1912












1913



  TAOS_RETURN(code);




748,707✔





1914



}










1915












1916



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




748,707✔





1917



  int32_t  code = 0;




748,707✔





1918



  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);




748,707✔





1919



  if (pCommitRaw == NULL) {




748,707✔





1920



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1921



    if (terrno != 0) code = terrno;




×







1922



    return -1;




×







1923



  }










1924



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));




748,707✔





1925



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));




748,707✔





1926












1927



  SSdb *pSdb = pMnode->pSdb;




748,707✔





1928



  void *pIter = NULL;




748,707✔





1929












1930



  while (1) {




4,674✔





1931



    SArbGroup *pArbGroup = NULL;




753,381✔





1932



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




753,381✔





1933



    if (pIter == NULL) break;




753,381✔





1934












1935



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




4,674✔





1936



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




4,674✔





1937



        sdbCancelFetch(pSdb, pIter);




×







1938



        sdbRelease(pSdb, pArbGroup);




×







1939



        TAOS_RETURN(code);




×







1940



      }










1941



    }










1942












1943



    sdbRelease(pSdb, pArbGroup);




4,674✔





1944



  }










1945












1946



  while (1) {




3,772,657✔





1947



    SVgObj *pVgroup = NULL;




4,521,364✔





1948



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




4,521,364✔





1949



    if (pIter == NULL) break;




4,521,364✔





1950












1951



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




3,772,657✔





1952



      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




1,593,132✔





1953



      if (pVgRaw == NULL) {




1,593,132✔





1954



        sdbCancelFetch(pSdb, pIter);




×







1955



        sdbRelease(pSdb, pVgroup);




×







1956



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1957



        if (terrno != 0) code = terrno;




×







1958



        TAOS_RETURN(code);




×







1959



      }










1960



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




1,593,132✔





1961



        sdbCancelFetch(pSdb, pIter);




×







1962



        sdbRelease(pSdb, pVgroup);




×







1963



        TAOS_RETURN(code);




×







1964



      }










1965



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




1,593,132✔





1966



        sdbCancelFetch(pSdb, pIter);




×







1967



        sdbRelease(pSdb, pVgroup);




×







1968



        TAOS_RETURN(code);




×







1969



      }










1970



    }










1971












1972



    sdbRelease(pSdb, pVgroup);




3,772,657✔





1973



  }










1974












1975



  while (1) {




1,318,760✔





1976



    SStbObj *pStb = NULL;




2,067,467✔





1977



    ESdbStatus status;




2,061,325✔





1978



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




2,067,467✔





1979



    if (pIter == NULL) break;




2,067,467✔





1980












1981



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




1,318,760✔





1982



      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);




647,716✔





1983



      if (pStbRaw == NULL) {




647,716✔





1984



        sdbCancelFetch(pSdb, pIter);




×







1985



        sdbRelease(pSdb, pStbRaw);




×







1986



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1987



        if (terrno != 0) code = terrno;




×







1988



        return -1;




×







1989



      }










1990



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




647,716✔





1991



        sdbCancelFetch(pSdb, pIter);




×







1992



        sdbRelease(pSdb, pStbRaw);




×







1993



        return -1;




×







1994



      }










1995



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




647,716✔





1996



        sdbCancelFetch(pSdb, pIter);




×







1997



        sdbRelease(pSdb, pStbRaw);




×







1998



        return -1;




×







1999



      }










2000



    }










2001












2002



    sdbRelease(pSdb, pStb);




1,318,760✔





2003



  }










2004












2005



  TAOS_RETURN(code);




748,707✔





2006



}










2007












2008



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




1,593,132✔





2009



  int32_t code = 0;




1,593,132✔





2010



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




3,259,374✔





2011



    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




1,666,242✔





2012



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




1,666,242✔





2013



  }










2014












2015



  TAOS_RETURN(code);




1,593,132✔





2016



}










2017












2018



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




748,707✔





2019



  int32_t code = 0;




748,707✔





2020



  SSdb   *pSdb = pMnode->pSdb;




748,707✔





2021



  void   *pIter = NULL;




748,707✔





2022












2023



  while (1) {




3,772,657✔





2024



    SVgObj *pVgroup = NULL;




4,521,364✔





2025



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




4,521,364✔





2026



    if (pIter == NULL) break;




4,521,364✔





2027












2028



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




3,772,657✔





2029



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




1,593,132✔





2030



        sdbCancelFetch(pSdb, pIter);




×







2031



        sdbRelease(pSdb, pVgroup);




×







2032



        TAOS_RETURN(code);




×







2033



      }










2034



    }










2035












2036



    sdbRelease(pSdb, pVgroup);




3,772,657✔





2037



  }










2038












2039



  TAOS_RETURN(code);




748,707✔





2040



}










2041












2042



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




1,306,261✔





2043



  int32_t    code = 0;




1,306,261✔





2044



  SDropDbRsp dropRsp = {0};




1,306,261✔





2045



  if (pDb != NULL) {




1,306,261✔





2046



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




748,069✔





2047



    dropRsp.uid = pDb->uid;




748,069✔





2048



  }










2049












2050



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




1,306,261✔





2051



  void   *pRsp = NULL;




1,306,261✔





2052



  if (useRpcMalloc) {




1,306,261✔





2053



    pRsp = rpcMallocCont(rspLen);




558,192✔





2054



  } else {










2055



    pRsp = taosMemoryMalloc(rspLen);




748,069✔





2056



  }










2057












2058



  if (pRsp == NULL) {




1,306,261✔





2059



    code = terrno;




×







2060



    TAOS_RETURN(code);




×







2061



  }










2062












2063



  int32_t ret = 0;




1,306,261✔





2064



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




1,306,261✔





2065



  *pRspLen = rspLen;




1,306,261✔





2066



  *ppRsp = pRsp;




1,306,261✔





2067



  TAOS_RETURN(code);




1,306,261✔





2068



}










2069












2070



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




748,458✔





2071



  int32_t code = -1;




748,458✔





2072












2073



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




748,458✔





2074



  if (pTrans == NULL) {




748,458✔





2075



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2076



    if (terrno != 0) code = terrno;




×







2077



    goto _OVER;




×







2078



  }










2079












2080



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




748,458✔





2081












2082



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




748,458✔





2083



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




748,458✔





2084












2085



  if (mndTopicExistsForDb(pMnode, pDb)) {




748,458✔





2086



    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;




389✔





2087



    goto _OVER;




389✔





2088



  }










2089












2090



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




748,069✔





2091



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




748,069✔





2092



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




748,069✔





2093



#ifdef TD_ENTERPRISE










2094



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




748,069✔





2095



#endif










2096



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




748,069✔





2097



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




748,069✔





2098



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




748,069✔





2099



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










2100



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




748,069✔





2101



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




748,069✔





2102












2103



  int32_t rspLen = 0;




748,069✔





2104



  void   *pRsp = NULL;




748,069✔





2105



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




748,069✔





2106



  mndTransSetRpcRsp(pTrans, pRsp, rspLen);




748,069✔





2107












2108



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




748,069✔





2109



  code = 0;




748,069✔





2110












2111



_OVER:




748,458✔





2112



  mndTransDrop(pTrans);




748,458✔





2113



  TAOS_RETURN(code);




748,458✔





2114



}










2115












2116



static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {




1,312,736✔





2117



  SMnode    *pMnode = pReq->info.node;




1,312,736✔





2118



  int32_t    code = -1;




1,312,736✔





2119



  SDbObj    *pDb = NULL;




1,312,736✔





2120



  SDropDbReq dropReq = {0};




1,312,736✔





2121



  int64_t    tss = taosGetTimestampMs();




1,312,736✔





2122












2123



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




1,312,736✔





2124












2125



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




1,312,736✔





2126












2127



  pDb = mndAcquireDb(pMnode, dropReq.db);




1,312,736✔





2128



  if (pDb == NULL) {




1,312,736✔





2129



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




562,385✔





2130



    if (terrno != 0) code = terrno;




562,385✔





2131



    int32_t ret =










2132



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




562,385✔





2133



    if (ret != 0) {




562,385✔





2134



      code = ret;




×







2135



      goto _OVER;




×







2136



    }










2137



    if (dropReq.ignoreNotExists) {




562,385✔





2138



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




558,192✔





2139



    }










2140



    goto _OVER;




562,385✔





2141



  }










2142












2143



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




750,351✔





2144



    goto _OVER;




×







2145



  }










2146












2147



  if(pDb->cfg.isMount) {




750,351✔





2148



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




638✔





2149



    goto _OVER;




638✔





2150



  }










2151












2152



  if(!pDb->cfg.allowDrop) {




749,713✔





2153



    code = TSDB_CODE_MND_DB_DROP_NOT_ALLOWED;




×







2154



    goto _OVER;




×







2155



  }










2156












2157



  SSdb *pSdb = pMnode->pSdb;




749,713✔





2158



  void *pIter = NULL;




749,713✔





2159












2160



  while (1) {




3,780,149✔





2161



    SVgObj *pVgroup = NULL;




4,529,862✔





2162



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




4,529,862✔





2163



    if (pIter == NULL) break;




4,529,862✔





2164












2165



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




3,780,149✔





2166



      bool isFound = false;




1,593,500✔





2167



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




3,260,110✔





2168



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




1,666,610✔






UNCOV

2169



          isFound = true;




×








UNCOV

2170



          break;




×







2171



        }










2172



      }










2173



      if (!isFound) {




1,593,500✔





2174



        sdbRelease(pSdb, pVgroup);




1,593,500✔





2175



        continue;




1,593,500✔





2176



      }











UNCOV

2177



      code = TSDB_CODE_MND_VGROUP_OFFLINE;




×








UNCOV

2178



      sdbCancelFetch(pSdb, pIter);




×








UNCOV

2179



      sdbRelease(pSdb, pVgroup);




×








UNCOV

2180



      goto _OVER;




×







2181



    }










2182












2183



    sdbRelease(pSdb, pVgroup);




2,186,649✔





2184



  }










2185












2186



  bool dbStream = false;




749,713✔





2187



  bool vtableStream = false;




749,713✔





2188



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




749,713✔





2189



  if (dbStream) {




749,713✔





2190



    code = TSDB_CODE_MND_STREAM_DB_IN_USE;




1,004✔





2191



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




1,004✔





2192



    goto _OVER;




1,004✔





2193



  }










2194












2195



  if (vtableStream && !dropReq.force) {




748,709✔





2196



    code = TSDB_CODE_MND_STREAM_VTABLE_EXITS;




251✔





2197



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




251✔





2198



    goto _OVER;




251✔





2199



  }










2200












2201



  code = mndDropDb(pMnode, pReq, pDb);




748,458✔





2202



  if (code == TSDB_CODE_SUCCESS) {




748,458✔





2203



    code = TSDB_CODE_ACTION_IN_PROGRESS;




748,069✔





2204



  }










2205












2206



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




748,458✔





2207



    SName name = {0};




748,458✔





2208



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




748,458✔





2209



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




×







2210












2211



    int64_t tse = taosGetTimestampMs();




748,458✔





2212



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




748,458✔





2213



    duration = duration / 1000;




748,458✔





2214



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




748,458✔





2215



  }










2216












2217



_OVER:




1,310,906✔





2218



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




1,312,736✔





2219



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




6,475✔





2220



  }










2221












2222



  mndReleaseDb(pMnode, pDb);




1,312,736✔





2223



  tFreeSDropDbReq(&dropReq);




1,312,736✔





2224



  TAOS_RETURN(code);




1,312,736✔





2225



}










2226












2227



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




31,485,612✔





2228



  int32_t numOfTables = 0;




31,485,612✔





2229



  int32_t vindex = 0;




31,485,612✔





2230



  SSdb   *pSdb = pMnode->pSdb;




31,485,612✔





2231












2232



  void *pIter = NULL;




31,485,539✔





2233



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




135,149,607✔





2234



    SVgObj *pVgroup = NULL;




103,663,991✔





2235



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




103,663,950✔





2236



    if (pIter == NULL) break;




103,664,027✔





2237












2238



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




103,664,027✔





2239



      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




63,777,432✔





2240



      vindex++;




63,777,391✔





2241



    }










2242












2243



    sdbRelease(pSdb, pVgroup);




103,663,945✔





2244



  }










2245












2246



  sdbCancelFetch(pSdb, pIter);




31,485,689✔





2247



  return numOfTables;




31,485,571✔





2248



}










2249












2250



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




30,755,061✔





2251



  int32_t vindex = 0;




30,755,061✔





2252



  SSdb   *pSdb = pMnode->pSdb;




30,755,061✔





2253












2254



  void *pIter = NULL;




30,755,061✔





2255



  while (1) {




70,479,676✔





2256



    SVgObj *pVgroup = NULL;




101,234,737✔





2257



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




101,234,666✔





2258



    if (pIter == NULL) break;




101,234,737✔





2259












2260



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




94,348,987✔





2261



      SVgroupInfo vgInfo = {0};




71,204,926✔





2262



      vgInfo.vgId = pVgroup->vgId;




71,204,926✔





2263



      vgInfo.hashBegin = pVgroup->hashBegin;




71,204,926✔





2264



      vgInfo.hashEnd = pVgroup->hashEnd;




71,204,926✔





2265



      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




71,204,885✔





2266



      vgInfo.epSet.numOfEps = pVgroup->replica;




71,204,926✔





2267



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




147,051,407✔





2268



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




75,846,366✔





2269



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




75,846,366✔





2270



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




75,846,407✔





2271



        if (pDnode != NULL) {




75,846,522✔





2272



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




75,811,882✔





2273



          pEp->port = pDnode->port;




75,811,882✔





2274



        }










2275



        mndReleaseDnode(pMnode, pDnode);




75,846,407✔





2276



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




75,846,522✔





2277



          vgInfo.epSet.inUse = gid;




70,725,310✔





2278



        }










2279



      }










2280



      vindex++;




71,204,926✔





2281



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




71,204,926✔





2282



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




×







2283



      }










2284



    }










2285












2286



    sdbRelease(pSdb, pVgroup);




94,348,987✔





2287












2288



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




94,348,987✔





2289



      sdbCancelFetch(pSdb, pIter);




23,869,311✔





2290



      break;




23,869,311✔





2291



    }










2292



  }










2293



}




30,755,061✔





2294












2295



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




24,202,920✔





2296



  int32_t code = 0;




24,202,920✔





2297



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




24,202,920✔





2298



  if (pRsp->pVgroupInfos == NULL) {




24,202,847✔





2299



    code = terrno;




×







2300



    TAOS_RETURN(code);




×







2301



  }










2302












2303



  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




24,202,838✔





2304












2305



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




24,202,879✔





2306



      pReq->stateTs < pDb->stateTs) {




1,485,851✔





2307



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




22,868,324✔





2308



  }










2309












2310



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




24,202,879✔





2311



  pRsp->uid = pDb->uid;




24,202,879✔





2312



  pRsp->vgVersion = pDb->vgVersion;




24,202,190✔





2313



  pRsp->stateTs = pDb->stateTs;




24,202,190✔





2314



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




24,202,154✔





2315



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




24,202,190✔





2316



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




24,202,190✔





2317



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




24,202,190✔





2318



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




24,202,190✔





2319



  TAOS_RETURN(code);




24,202,195✔





2320



}










2321












2322



static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {




30,975,505✔





2323



  SMnode   *pMnode = pReq->info.node;




30,975,505✔





2324



  int32_t   code = -1;




30,975,505✔





2325



  SDbObj   *pDb = NULL;




30,975,505✔





2326



  SUseDbReq usedbReq = {0};




30,975,505✔





2327



  SUseDbRsp usedbRsp = {0};




30,975,505✔





2328












2329



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




30,975,505✔





2330












2331



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




30,975,514✔





2332



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




30,975,514✔





2333



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




6,566,699✔





2334



    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




6,566,699✔





2335



    if (usedbReq.vgVersion < vgVersion) {




6,565,755✔





2336



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




6,557,624✔





2337



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




6,557,624✔





2338












2339



      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);




6,557,624✔





2340



      usedbRsp.vgVersion = vgVersion++;




6,557,624✔





2341



    } else {










2342



      usedbRsp.vgVersion = usedbReq.vgVersion;




8,131✔





2343



    }










2344



    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);




6,565,755✔





2345



    code = 0;




6,565,755✔





2346



  } else {










2347



    pDb = mndAcquireDb(pMnode, usedbReq.db);




24,408,815✔





2348



    if (pDb == NULL) {




24,407,628✔





2349



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




199,435✔





2350



      usedbRsp.uid = usedbReq.dbId;




199,435✔





2351



      usedbRsp.vgVersion = usedbReq.vgVersion;




199,435✔





2352



      usedbRsp.errCode = terrno;




199,435✔





2353












2354



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




199,435✔





2355



      if (terrno != 0) code = terrno;




199,435✔





2356



      goto _OVER;




199,435✔





2357



    } else {










2358



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




24,208,193✔





2359












2360



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




24,202,920✔





2361












2362



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




24,202,190✔





2363



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










2364



      code = 0;




24,202,920✔





2365



    }










2366



  }










2367












2368



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




30,768,675✔





2369



  void   *pRsp = rpcMallocCont(contLen);




30,768,675✔





2370



  if (pRsp == NULL) {




30,768,675✔





2371



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2372



    code = -1;




×







2373



    goto _OVER;




×







2374



  }










2375












2376



  int32_t ret = 0;




30,768,675✔





2377



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




30,768,675✔





2378



    code = ret;




×







2379



    goto _OVER;




×







2380



  }










2381












2382



  pReq->info.rsp = pRsp;




30,768,675✔





2383



  pReq->info.rspLen = contLen;




30,767,896✔





2384












2385



_OVER:




30,974,138✔





2386



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




30,974,917✔





2387



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




206,871✔





2388



  }










2389












2390



  mndReleaseDb(pMnode, pDb);




30,974,917✔





2391



  tFreeSUsedbRsp(&usedbRsp);




30,975,546✔





2392












2393



  TAOS_RETURN(code);




30,975,546✔





2394



}










2395












2396



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




9,007,636✔





2397



  int32_t       code = 0;




9,007,636✔





2398



  SDbHbBatchRsp batchRsp = {0};




9,007,636✔





2399



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




9,007,636✔





2400



  if (batchRsp.pArray == NULL) {




9,007,636✔





2401



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2402



    TAOS_RETURN(code);




×







2403



  }










2404












2405



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




19,905,308✔





2406



    SDbCacheInfo *pDbCacheInfo = &pDbs[i];




10,897,672✔





2407



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




10,897,672✔





2408



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




10,897,672✔





2409



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




10,897,672✔





2410



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




10,897,672✔





2411



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




10,897,672✔





2412



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




10,897,672✔





2413












2414



    SDbHbRsp rsp = {0};




10,897,672✔





2415



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




10,897,672✔





2416



    rsp.dbId = pDbCacheInfo->dbId;




10,897,672✔





2417












2418



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




10,897,672✔





2419



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




10,273,661✔





2420



      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




3,568,590✔





2421



      if (pDbCacheInfo->vgVersion >= vgVersion) {




3,568,590✔





2422



        continue;




3,240,902✔





2423



      }










2424












2425



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




328,126✔





2426



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




328,126✔





2427



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




328,126✔





2428












2429



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




328,126✔





2430



      rsp.useDbRsp->vgVersion = vgVersion++;




328,126✔





2431












2432



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




328,126✔





2433












2434



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




656,252✔





2435



        if (terrno != 0) code = terrno;




×







2436



        return code;




×







2437



      }










2438












2439



      continue;




328,126✔





2440



    }










2441












2442



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




7,329,082✔





2443



    if (pDb == NULL) {




7,329,082✔





2444



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




46,390✔





2445



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




46,390✔





2446



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




46,390✔





2447



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




46,390✔





2448



      rsp.useDbRsp->vgVersion = -1;




46,390✔





2449



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




92,780✔





2450



        if (terrno != 0) code = terrno;




×







2451



        return code;




×







2452



      }










2453



      continue;




46,390✔





2454



    }










2455












2456



    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




7,282,692✔





2457












2458



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




7,282,692✔





2459



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




7,165,872✔





2460



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




6,224,724✔





2461



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




5,835,587✔





2462



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










2463



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










2464



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










2465



      mndReleaseDb(pMnode, pDb);




5,835,587✔





2466



      continue;




5,835,587✔





2467



    } else {










2468



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




1,447,105✔





2469



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










2470



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










2471



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










2472



    }










2473












2474



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




1,447,105✔





2475



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




86,537✔





2476



      char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




86,537✔





2477



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




86,537✔





2478



      mndDumpDbCfgInfo(rsp.cfgRsp, pDb, algrId);




86,537✔





2479



    }










2480












2481



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




1,447,105✔





2482



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




955,675✔





2483



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




955,675✔





2484



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




955,675✔





2485



        bool    exist = false;




955,675✔





2486



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




955,675✔





2487



        if (TSDB_CODE_SUCCESS != code) {




955,675✔





2488



          mndReleaseDb(pMnode, pDb);




3,034✔





2489



          if (code != TSDB_CODE_NEED_RETRY) {




3,034✔





2490



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




3,034✔





2491



          } else {










2492



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




×







2493



          }










2494



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




3,034✔





2495



          taosMemoryFreeClear(rsp.pTsmaRsp);




3,034✔





2496



          continue;




3,034✔





2497



        }










2498



        rsp.dbTsmaVersion = pDb->tsmaVersion;




952,641✔





2499



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




952,641✔





2500



      }










2501



    }










2502












2503



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




1,444,071✔





2504



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




1,395,718✔





2505



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




1,000,946✔





2506



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




1,000,946✔





2507



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




1,000,946✔





2508



        mndReleaseDb(pMnode, pDb);




×







2509



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




×







2510



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




×







2511



        taosMemoryFreeClear(rsp.pTsmaRsp);




×







2512



        continue;




×







2513



      }










2514












2515



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




1,000,946✔





2516



      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);




1,000,946✔





2517



      rsp.useDbRsp->uid = pDb->uid;




1,000,946✔





2518



      rsp.useDbRsp->vgVersion = pDb->vgVersion;




1,000,946✔





2519



      rsp.useDbRsp->stateTs = pDb->stateTs;




1,000,946✔





2520



      rsp.useDbRsp->vgNum = (int32_t)taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);




1,000,946✔





2521



      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;




1,000,946✔





2522



      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;




1,000,946✔





2523



      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;




1,000,946✔





2524



      rsp.useDbRsp->flags = pDb->cfg.flags;




1,000,946✔





2525



    }










2526












2527



    if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {




2,888,142✔





2528



      mndReleaseDb(pMnode, pDb);




×







2529



      if (terrno != 0) code = terrno;




×







2530



      return code;




×







2531



    }










2532



    mndReleaseDb(pMnode, pDb);




1,444,071✔





2533



  }










2534












2535



  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);




9,007,636✔





2536



  void   *pRsp = taosMemoryMalloc(rspLen);




9,007,636✔





2537



  if (pRsp == NULL) {




9,007,636✔





2538



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2539



    tFreeSDbHbBatchRsp(&batchRsp);




×







2540



    return -1;




×







2541



  }










2542



  int32_t ret = 0;




9,007,636✔





2543



  if ((ret = tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp)) < 0) return ret;




9,007,636✔





2544












2545



  *ppRsp = pRsp;




9,007,636✔





2546



  *pRspLen = rspLen;




9,007,636✔





2547












2548



  tFreeSDbHbBatchRsp(&batchRsp);




9,007,636✔





2549



  TAOS_RETURN(code);




9,007,636✔





2550



}










2551












2552



static int32_t mndSetTrimDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t startTs, STimeWindow tw,




33,979✔





2553



                                       SArray *vgroupIds, ETsdbOpType type, ETriggerType triggerType,










2554



                                       STrimDbRsp *pRsp) {










2555



  int32_t code = 0, lino = 0;




33,979✔





2556



  SSdb   *pSdb = pMnode->pSdb;




33,979✔





2557



  void   *pIter = NULL;




33,979✔





2558












2559



  SRetentionObj obj = {.optrType = type, .triggerType = triggerType};  // reuse SCompactObj struct




33,979✔





2560



  TAOS_CHECK_EXIT(mndAddRetentionToTrans(pMnode, pTrans, &obj, pDb, pRsp));




33,979✔





2561












2562



  int32_t j = 0;




33,979✔





2563



  int32_t numOfVgroups = taosArrayGetSize(vgroupIds);




33,979✔





2564



  if (numOfVgroups > 0) {




33,979✔





2565



    for (int32_t i = 0; i < numOfVgroups; i++) {




9,348✔





2566



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




7,011✔





2567



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




7,011✔





2568












2569



      if (pVgroup == NULL) {




7,011✔





2570



        mError("db:%s, vgroup:%" PRId64 " not exist", pDb->name, vgId);




2,337✔





2571



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




2,337✔





2572



      } else if (pVgroup->dbUid != pDb->uid) {




4,674✔





2573



        mError("db:%s, vgroup:%" PRId64 " not belong to db:%s", pDb->name, vgId, pDb->name);




×







2574



        sdbRelease(pSdb, pVgroup);




×







2575



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




×







2576



      }










2577



      sdbRelease(pSdb, pVgroup);




4,674✔





2578



    }










2579












2580



    for (int32_t i = 0; i < numOfVgroups; i++) {




7,011✔





2581



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




4,674✔





2582



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




4,674✔





2583












2584



      if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




4,674✔





2585



        sdbRelease(pSdb, pVgroup);




×







2586



        TAOS_RETURN(code);




×







2587



      }










2588












2589



      for (int32_t i = 0; i < pVgroup->replica; i++) {




9,348✔





2590



        SVnodeGid *gid = &pVgroup->vnodeGid[i];




4,674✔





2591



        if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




4,674✔





2592



          sdbRelease(pSdb, pVgroup);




×







2593



          TAOS_RETURN(code);




×







2594



        }










2595



        j++;




4,674✔





2596



      }










2597



      sdbRelease(pSdb, pVgroup);




4,674✔





2598



    }










2599



  } else {










2600



    while (1) {




110,557✔





2601



      SVgObj *pVgroup = NULL;




139,862✔





2602



      pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




139,862✔





2603



      if (pIter == NULL) break;




139,862✔





2604












2605



      if (pVgroup->dbUid == pDb->uid) {




110,557✔





2606



        if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




66,059✔





2607



          sdbCancelFetch(pSdb, pIter);




×







2608



          sdbRelease(pSdb, pVgroup);




×







2609



          TAOS_RETURN(code);




×







2610



        }










2611












2612



        for (int32_t i = 0; i < pVgroup->replica; i++) {




147,752✔





2613



          SVnodeGid *gid = &pVgroup->vnodeGid[i];




81,693✔





2614



          if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




81,693✔





2615



            sdbCancelFetch(pSdb, pIter);




×







2616



            sdbRelease(pSdb, pVgroup);




×







2617



            TAOS_RETURN(code);




×







2618



          }










2619



          j++;




81,693✔





2620



        }










2621



      }










2622












2623



      sdbRelease(pSdb, pVgroup);




110,557✔





2624



    }










2625



  }










2626



_exit:




33,979✔





2627



  TAOS_RETURN(code);




33,979✔





2628



}










2629












2630



static int32_t mndBuildTrimDbRsp(STrimDbRsp *rsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




31,642✔





2631



  int32_t code = 0;




31,642✔





2632



  int32_t rspLen = tSerializeSCompactDbRsp(NULL, 0, (SCompactDbRsp *)rsp);




31,642✔





2633



  void   *pRsp = NULL;




31,642✔





2634



  if (useRpcMalloc) {




31,642✔





2635



    pRsp = rpcMallocCont(rspLen);




×







2636



  } else {










2637



    pRsp = taosMemoryMalloc(rspLen);




31,642✔





2638



  }










2639












2640



  if (pRsp == NULL) {




31,642✔





2641



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2642



    TAOS_RETURN(code);




×







2643



  }










2644












2645



  (void)tSerializeSCompactDbRsp(pRsp, rspLen, (SCompactDbRsp *)rsp);




31,642✔





2646



  *pRspLen = rspLen;




31,642✔





2647



  *ppRsp = pRsp;




31,642✔





2648



  TAOS_RETURN(code);




31,642✔





2649



}










2650












2651



int32_t mndTrimDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, STimeWindow tw, SArray *vgroupIds,




38,847✔





2652



                         ETsdbOpType type, ETriggerType triggerType) {










2653



  SSdb      *pSdb = pMnode->pSdb;




38,847✔





2654



  SVgObj    *pVgroup = NULL;




38,847✔





2655



  void      *pIter = NULL;




38,847✔





2656



  int32_t    code = 0, lino = 0;




38,847✔





2657



  STrimDbRsp rsp = {0};




38,847✔





2658



  bool       isExist = false;




38,847✔





2659












2660



  while (1) {




10,520✔





2661



    SRetentionObj *pObj = NULL;




49,367✔





2662



    pIter = sdbFetch(pMnode->pSdb, SDB_RETENTION, pIter, (void **)&pObj);




49,367✔





2663



    if (pIter == NULL) break;




49,367✔





2664












2665



    if (strcmp(pObj->dbname, pDb->name) == 0) {




10,520✔





2666



      isExist = true;




4,674✔





2667



    }










2668



    sdbRelease(pMnode->pSdb, pObj);




10,520✔





2669



  }










2670



  if (isExist) {




38,847✔





2671



    mInfo("trim db:%s already exist", pDb->name);




4,674✔





2672



    TAOS_RETURN(TSDB_CODE_MND_TRIM_ALREADY_EXIST);




4,674✔





2673



  }










2674












2675



  int64_t startTs = taosGetTimestampMs();




34,173✔





2676



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "trim-db");




34,173✔





2677



  if (pTrans == NULL) goto _exit;




34,173✔





2678



  mInfo("trans:%d, used to trim db:%s", pTrans->id, pDb->name);




34,173✔





2679



  mndTransSetDbName(pTrans, pDb->name, NULL);




34,173✔





2680



  TAOS_CHECK_EXIT(mndTrancCheckConflict(pMnode, pTrans));




34,173✔





2681



  TAOS_CHECK_EXIT(mndSetTrimDbRedoActions(pMnode, pTrans, pDb, startTs, tw, vgroupIds, type, triggerType, &rsp));




33,979✔





2682



  if (pReq) {




31,642✔





2683



    int32_t rspLen = 0;




31,642✔





2684



    void   *pRsp = NULL;




31,642✔





2685



    rsp.bAccepted = true;




31,642✔





2686



    TAOS_CHECK_EXIT(mndBuildTrimDbRsp(&rsp, &rspLen, &pRsp, false));




31,642✔





2687



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




31,642✔





2688



  }










2689



  TAOS_CHECK_EXIT(mndTransPrepare(pMnode, pTrans));




31,642✔





2690



_exit:




34,173✔





2691



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {




34,173✔





2692



    mError("db:%s, failed at line %d to trim db since %s", pDb->name, lino, tstrerror(code));




2,531✔





2693



  }










2694



  mndTransDrop(pTrans);




34,173✔





2695



  TAOS_RETURN(code);




34,173✔





2696



}










2697












2698



#ifdef TD_ENTERPRISE










2699



static int32_t mndCheckRsmaInDb(SMnode *pMnode, SDbObj *pDb) {




14,801✔





2700



  int32_t   code = 0;




14,801✔





2701



  void     *pIter = NULL;




14,801✔





2702



  SRsmaObj *pRsma = NULL;




14,801✔





2703



  while ((pIter = sdbFetch(pMnode->pSdb, SDB_RSMA, pIter, (void **)&pRsma))) {




14,801✔





2704



    if (pRsma->dbUid == pDb->uid) {




14,801✔





2705



      sdbRelease(pMnode->pSdb, pRsma);




14,801✔





2706



      sdbCancelFetch(pMnode->pSdb, pIter);




14,801✔





2707



      TAOS_RETURN(code);




14,801✔





2708



    }










2709



    sdbRelease(pMnode->pSdb, pRsma);




×







2710



  }










2711



  TAOS_RETURN(TSDB_CODE_RSMA_NOT_EXIST);




×







2712



}










2713



#endif










2714












2715



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {




23,713✔





2716



  SMnode    *pMnode = pReq->info.node;




23,713✔





2717



  int32_t    code = 0, lino = 0;




23,713✔





2718



  SDbObj    *pDb = NULL;




23,713✔





2719



  STrimDbReq trimReq = {0};




23,713✔





2720



  int64_t    tss = taosGetTimestampMs();




23,713✔





2721












2722



  TAOS_CHECK_EXIT(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq));




23,713✔





2723












2724



  mInfo("db:%s, start to trim, optr:%u, tw:%" PRId64 ",%" PRId64, trimReq.db, trimReq.optrType, trimReq.tw.skey,




23,713✔





2725



        trimReq.tw.ekey);










2726












2727



  pDb = mndAcquireDb(pMnode, trimReq.db);




23,713✔





2728



  if (pDb == NULL) {




23,713✔





2729



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2730



    if (terrno != 0) code = terrno;




×







2731



    TAOS_CHECK_EXIT(code);




×







2732



  }










2733












2734



  TAOS_CHECK_EXIT(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb));




23,713✔





2735












2736



  if (pDb->cfg.isMount) {




23,713✔





2737



    TAOS_CHECK_EXIT(TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT);




×







2738



  }










2739












2740



#ifdef TD_ENTERPRISE










2741



  if (trimReq.optrType == TSDB_OPTR_ROLLUP) {




23,713✔





2742



    TAOS_CHECK_EXIT(mndCheckRsmaInDb(pMnode, pDb));




14,801✔





2743



  }










2744



#endif










2745












2746



  TAOS_CHECK_EXIT(mndTrimDb(pMnode, pReq, pDb, trimReq.tw, trimReq.vgroupIds, trimReq.optrType, trimReq.triggerType));




23,713✔





2747



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




16,702✔





2748












2749



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




16,702✔





2750



    SName name = {0};




16,702✔





2751



    if (tNameFromString(&name, trimReq.db, T_NAME_ACCT | T_NAME_DB) < 0) {




16,702✔





2752



      mWarn("db:%s, failed at line %d to parse db name", trimReq.db, __LINE__);




×







2753



    }










2754












2755



    char optrType[16] = {0};




16,702✔





2756



    (void)snprintf(optrType, sizeof(optrType), "%u", trimReq.optrType);




16,702✔





2757



    int64_t tse = taosGetTimestampMs();




16,702✔





2758



    double  duration = (double)(tse - tss);




16,702✔





2759



    duration = duration / 1000;




16,702✔





2760



    auditRecord(pReq, pMnode->clusterId, "trimDB", name.dbname, optrType, trimReq.sql, trimReq.sqlLen, duration, 0);




16,702✔





2761



  }










2762












2763



_exit:




23,713✔





2764



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {




23,713✔





2765



    mError("db:%s, failed at line %d to process trim db req since %s, optr:%u", trimReq.db, lino, tstrerror(code),




7,011✔





2766



           trimReq.optrType);










2767



  }










2768












2769



  mndReleaseDb(pMnode, pDb);




23,713✔





2770



  tFreeSTrimDbReq(&trimReq);




23,713✔





2771



  TAOS_RETURN(code);




23,713✔





2772



}










2773












2774



static int32_t mndBuildSsMigrateDbRsp(SSsMigrateDbRsp *pSsMigrateRsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




2,337✔





2775



  int32_t code = 0;




2,337✔





2776



  int32_t rspLen = tSerializeSSsMigrateDbRsp(NULL, 0, pSsMigrateRsp);




2,337✔





2777



  void   *pRsp = NULL;




2,337✔





2778



  if (useRpcMalloc) {




2,337✔





2779



    pRsp = rpcMallocCont(rspLen);




×







2780



  } else {










2781



    pRsp = taosMemoryMalloc(rspLen);




2,337✔





2782



  }










2783












2784



  if (pRsp == NULL) {




2,337✔





2785



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2786



    TAOS_RETURN(code);




×







2787



  }










2788












2789



  (void)tSerializeSSsMigrateDbRsp(pRsp, rspLen, pSsMigrateRsp);




2,337✔





2790



  *pRspLen = rspLen;




2,337✔





2791



  *ppRsp = pRsp;




2,337✔





2792



  TAOS_RETURN(code);




2,337✔





2793



}










2794












2795



static int32_t mndTrimDbWal(SMnode *pMnode, SDbObj *pDb) {




1,186✔





2796



  SSdb   *pSdb = pMnode->pSdb;




1,186✔





2797



  SVgObj *pVgroup = NULL;




1,186✔





2798



  void   *pIter = NULL;




1,186✔





2799



  int32_t code = 0;




1,186✔





2800












2801



  // Iterate through all vgroups in this database










2802



  while (1) {




2,372✔





2803



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




3,558✔





2804



    if (pIter == NULL) break;




3,558✔





2805












2806



    // Check if this vgroup belongs to the database










2807



    if (pVgroup->dbUid != pDb->uid) {




2,372✔





2808



      sdbRelease(pSdb, pVgroup);




×







2809



      continue;




×







2810



    }










2811












2812



    // Prepare message to send to vnode










2813



    int32_t   contLen = sizeof(SMsgHead);




2,372✔





2814



    SMsgHead *pHead = rpcMallocCont(contLen);




2,372✔





2815



    if (pHead == NULL) {




2,372✔





2816



      sdbCancelFetch(pSdb, pVgroup);




×







2817



      sdbRelease(pSdb, pVgroup);




×







2818



      code = TSDB_CODE_OUT_OF_MEMORY;




×







2819



      break;




×







2820



    }










2821



    pHead->contLen = htonl(contLen);




2,372✔





2822



    pHead->vgId = htonl(pVgroup->vgId);




2,372✔





2823












2824



    // Send TRIM WAL request to vnode










2825



    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM_WAL, .pCont = pHead, .contLen = contLen};




2,372✔





2826



    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);




2,372✔





2827



    code = tmsgSendReq(&epSet, &rpcMsg);




2,372✔





2828



    if (code != 0) {




2,372✔





2829



      mError("vgId:%d, failed to send vnode-trim-wal request since 0x%x", pVgroup->vgId, code);




×







2830



    } else {










2831



      mInfo("vgId:%d, send vnode-trim-wal request to vnode", pVgroup->vgId);




2,372✔





2832



    }










2833



    sdbRelease(pSdb, pVgroup);




2,372✔





2834



  }










2835












2836



  return code;




1,186✔





2837



}










2838












2839



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq) {




1,186✔





2840



  SMnode    *pMnode = pReq->info.node;




1,186✔





2841



  int32_t    code = -1;




1,186✔





2842



  SDbObj    *pDb = NULL;




1,186✔





2843



  STrimDbReq trimReq = {0};




1,186✔





2844












2845



  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);




1,186✔





2846












2847



  mInfo("db:%s, start to trim WAL", trimReq.db);




1,186✔





2848












2849



  pDb = mndAcquireDb(pMnode, trimReq.db);




1,186✔





2850



  if (pDb == NULL) {




1,186✔





2851



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2852



    if (terrno != 0) code = terrno;




×







2853



    goto _OVER;




×







2854



  }










2855












2856



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb), NULL, _OVER);




1,186✔





2857












2858



  code = mndTrimDbWal(pMnode, pDb);




1,186✔





2859












2860



_OVER:




1,186✔





2861



  if (code != 0) {




1,186✔





2862



    mError("db:%s, failed to process trim db wal req since %s", trimReq.db, terrstr());




×







2863



  }










2864












2865



  mndReleaseDb(pMnode, pDb);




1,186✔





2866



  TAOS_RETURN(code);




1,186✔





2867



}










2868












2869



int32_t mndSsMigrateDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {




2,337✔





2870



  int32_t       code = 0;




2,337✔





2871



  SSsMigrateDbRsp ssMigrateRsp = {0};




2,337✔





2872












2873



  bool  isExist = false;




2,337✔





2874



  void *pIter = NULL;




2,337✔





2875



  while (1) {




×







2876



    SSsMigrateObj *pSsMigrate = NULL;




2,337✔





2877



    pIter = sdbFetch(pMnode->pSdb, SDB_SSMIGRATE, pIter, (void **)&pSsMigrate);




2,337✔





2878



    if (pIter == NULL) break;




2,337✔





2879












2880



    if (strcmp(pSsMigrate->dbname, pDb->name) == 0) {




×







2881



      isExist = true;




×







2882



    }










2883



    sdbRelease(pMnode->pSdb, pSsMigrate);




×







2884



  }










2885



  if (isExist) {




2,337✔





2886



    mInfo("ssmigrate db:%s already exist", pDb->name);




×







2887












2888



    if (pReq) {




×







2889



      int32_t rspLen = 0;




×







2890



      void   *pRsp = NULL;




×







2891



      ssMigrateRsp.ssMigrateId = 0;




×







2892



      ssMigrateRsp.bAccepted = false;




×







2893



      TAOS_CHECK_RETURN(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, true));




×







2894












2895



      pReq->info.rsp = pRsp;




×







2896



      pReq->info.rspLen = rspLen;




×







2897



    }










2898












2899



    return TSDB_CODE_MND_SSMIGRATE_ALREADY_EXIST;




×







2900



  }










2901












2902



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "ssmigrate-db");




2,337✔





2903



  if (pTrans == NULL) {




2,337✔





2904



    mError("failed to create ssmigrate-db trans since %s", terrstr());




×







2905



    goto _OVER;




×







2906



  }










2907












2908



  mInfo("trans:%d, used to ssmigrate db:%s", pTrans->id, pDb->name);




2,337✔





2909



  mndTransSetDbName(pTrans, pDb->name, NULL);




2,337✔





2910



  TAOS_CHECK_GOTO(mndTrancCheckConflict(pMnode, pTrans), NULL, _OVER);




2,337✔





2911












2912



  SSsMigrateObj ssMigrate = { .startTime = taosGetTimestampMs() };




2,337✔





2913



  TAOS_CHECK_GOTO(mndAddSsMigrateToTran(pMnode, pTrans, &ssMigrate, pDb), NULL, _OVER);




2,337✔





2914












2915



  if (pReq) {




2,337✔





2916



    int32_t rspLen = 0;




2,337✔





2917



    void   *pRsp = NULL;




2,337✔





2918



    ssMigrateRsp.ssMigrateId = ssMigrate.id;




2,337✔





2919



    ssMigrateRsp.bAccepted = true;




2,337✔





2920



    TAOS_CHECK_GOTO(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, false), NULL, _OVER);




2,337✔





2921



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




2,337✔





2922



  }










2923












2924



  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;




2,337✔





2925



  code = 0;




2,337✔





2926












2927



_OVER:




2,337✔





2928



  mndTransDrop(pTrans);




2,337✔





2929



  TAOS_RETURN(code);




2,337✔





2930



}










2931












2932












2933



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq) {




2,651✔





2934



  SMnode         *pMnode = pReq->info.node;




2,651✔





2935



  int32_t         code = -1;




2,651✔





2936



  SDbObj         *pDb = NULL;




2,651✔





2937



  SSsMigrateDbReq ssMigrateReq = {0};




2,651✔





2938












2939



  if (!tsSsEnabled) {




2,651✔





2940



    code = TSDB_CODE_OPS_NOT_SUPPORT;




314✔





2941



    goto _OVER;




314✔





2942



  }










2943












2944



  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_SHARED_STORAGE), NULL, _OVER);




2,337✔





2945



  TAOS_CHECK_GOTO(tDeserializeSSsMigrateDbReq(pReq->pCont, pReq->contLen, &ssMigrateReq), NULL, _OVER);




2,337✔





2946












2947



  mInfo("db:%s, start to ssmigrate", ssMigrateReq.db);




2,337✔





2948












2949



  pDb = mndAcquireDb(pMnode, ssMigrateReq.db);




2,337✔





2950



  if (pDb == NULL) {




2,337✔





2951



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2952



    if (terrno != 0) code = terrno;




×







2953



    goto _OVER;




×







2954



  }










2955












2956



  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SSMIGRATE_DB, pDb), NULL, _OVER);




2,337✔





2957












2958



  if(pDb->cfg.isMount) {




2,337✔





2959



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×







2960



    goto _OVER;




×







2961



  }










2962












2963



  code = mndSsMigrateDb(pMnode, pReq, pDb);




2,337✔





2964












2965



_OVER:




2,651✔





2966



  if (code != 0) {




2,651✔





2967



    mError("db:%s, failed to process ssmigrate db req since %s", ssMigrateReq.db, tstrerror(code));




314✔





2968



  }










2969












2970



  mndReleaseDb(pMnode, pDb);




2,651✔





2971



  TAOS_RETURN(code);




2,651✔





2972



}










2973












2974



const char *mndGetDbStr(const char *src) {




19,989,513✔





2975



  char *pos = strstr(src, TS_PATH_DELIMITER);




19,989,513✔





2976



  if (pos != NULL) ++pos;




19,989,513✔





2977



  if (pos == NULL) return src;




19,989,513✔





2978



  return pos;




18,555,986✔





2979



}










2980












2981



const char *mndGetStableStr(const char *src) {




16,488,612✔





2982



  char *pos = strstr(src, TS_PATH_DELIMITER);




16,488,612✔





2983



  if (pos != NULL) ++pos;




16,488,612✔





2984



  if (pos == NULL) return src;




16,488,612✔





2985



  return mndGetDbStr(pos);




16,488,612✔





2986



}










2987












2988



static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {




×







2989



  int64_t v = 0;




×







2990



  switch (unit) {




×







2991



    case 's':




×







2992



      v = val / 1000;




×







2993



      break;




×







2994



    case 'm':




×







2995



      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];




×







2996



      break;




×







2997



    case 'h':




×







2998



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);




×







2999



      break;




×







3000



    case 'd':




×







3001



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);




×







3002



      break;




×







3003



    case 'w':




×







3004



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);




×







3005



      break;




×







3006



    default:




×







3007



      break;




×







3008



  }










3009












3010



  return v;




×







3011



}










3012












3013



static char *buildRetension(SArray *pRetension) {




623,168✔





3014



  size_t size = taosArrayGetSize(pRetension);




623,168✔





3015



  if (size == 0) {




623,168✔





3016



    return NULL;




623,168✔





3017



  }










3018












3019



  char       *p1 = taosMemoryCalloc(1, 100);




×







3020



  SRetention *p = taosArrayGet(pRetension, 0);




×







3021












3022



  int32_t len = 2;




×







3023












3024



  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3025



  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3026



  len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3027












3028



  if (size > 1) {




×







3029



    len += snprintf(p1 + len, 100 - len, ",");




×







3030



    p = taosArrayGet(pRetension, 1);




×







3031












3032



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3033



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3034



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3035



  }










3036












3037



  if (size > 2) {




×







3038



    len += snprintf(p1 + len, 100 - len, ",");




×







3039



    p = taosArrayGet(pRetension, 2);




×







3040












3041



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3042



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3043



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3044



  }










3045












3046



  varDataSetLen(p1, len);




×







3047



  return p1;




×







3048



}










3049












3050



static const char *getCacheModelStr(int8_t cacheModel) {




623,168✔





3051



  switch (cacheModel) {




623,168✔





3052



    case TSDB_CACHE_MODEL_NONE:




563,235✔





3053



      return TSDB_CACHE_MODEL_NONE_STR;




563,235✔





3054



    case TSDB_CACHE_MODEL_LAST_ROW:




3,602✔





3055



      return TSDB_CACHE_MODEL_LAST_ROW_STR;




3,602✔





3056



    case TSDB_CACHE_MODEL_LAST_VALUE:




7,311✔





3057



      return TSDB_CACHE_MODEL_LAST_VALUE_STR;




7,311✔





3058



    case TSDB_CACHE_MODEL_BOTH:




49,020✔





3059



      return TSDB_CACHE_MODEL_BOTH_STR;




49,020✔





3060



    default:




×







3061



      break;




×







3062



  }










3063



  return "unknown";




×







3064



}










3065












3066



static void getEncryptAlgorithmStr(SMnode *pMnode, int8_t encryptAlgorithm, char *out) {




623,168✔





3067



  switch (encryptAlgorithm) {




623,168✔





3068



    case TSDB_ENCRYPT_ALGO_NONE: {




621,918✔





3069



      tstrncpy(out, TSDB_ENCRYPT_ALGO_NONE_STR, TSDB_ENCRYPT_ALGR_NAME_LEN);




621,918✔





3070



      break;




621,918✔





3071



    }










3072



    default: {




1,250✔





3073



      SEncryptAlgrObj *obj = mndAcquireEncryptAlgrById(pMnode, encryptAlgorithm);




1,250✔





3074



      if (obj != NULL) {




1,250✔





3075



        tstrncpy(out, obj->algorithm_id, TSDB_ENCRYPT_ALGR_NAME_LEN);




1,250✔





3076



        mndReleaseEncryptAlgr(pMnode, obj);




1,250✔





3077



      }










3078



      break;




1,250✔





3079



    }










3080



  }










3081



}




623,168✔





3082












3083



bool mndIsDbReady(SMnode *pMnode, SDbObj *pDb) {




2,366,422✔





3084



  if (pDb->cfg.replications == 1) return true;




2,366,422✔





3085












3086



  SSdb *pSdb = pMnode->pSdb;




469,755✔





3087



  void *pIter = NULL;




469,755✔





3088



  bool  isReady = true;




469,755✔





3089



  while (1) {




2,329,734✔





3090



    SVgObj *pVgroup = NULL;




2,799,489✔





3091



    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);




2,799,489✔





3092



    if (pIter == NULL) break;




2,799,489✔





3093












3094



    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {




2,329,734✔





3095



      bool hasLeader = false;




1,371,276✔





3096



      for (int32_t i = 0; i < pVgroup->replica; ++i) {




5,420,563✔





3097



        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||




4,049,287✔





3098



            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {




3,543,687✔





3099



          hasLeader = true;




505,600✔





3100



        }










3101



      }










3102



      if (!hasLeader) isReady = false;




1,371,276✔





3103



    }










3104



    sdbRelease(pSdb, pVgroup);




2,329,734✔





3105



  }










3106












3107



  return isReady;




469,755✔





3108



}










3109












3110



static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,




1,671,862✔





3111



                              int64_t numOfTables, bool sysDb, ESdbStatus objStatus, bool sysinfo,










3112



                              SSHashObj **ppUidNames) {










3113



  int32_t cols = 0;




1,671,862✔





3114



  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;




1,671,862✔





3115



  char   *buf = taosMemoryMalloc(bytes);




1,671,862✔





3116



  if (buf == NULL) {




1,671,862✔





3117



    mError("db:%s, failed to malloc buffer", pDb->name);




×







3118



    return;




×







3119



  }










3120



  int32_t code = 0;




1,671,862✔





3121



  int32_t lino = 0;




1,671,862✔





3122












3123



  const char *name = mndGetDbStr(pDb->name);




1,671,862✔





3124



  if (name != NULL) {




1,671,862✔





3125



    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);




1,671,862✔





3126



  } else {










3127



    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);




×







3128



  }










3129












3130



  const char *precStr = NULL;




1,671,862✔





3131



  switch (pDb->cfg.precision) {




1,671,862✔





3132



    case TSDB_TIME_PRECISION_MILLI:




1,624,013✔





3133



      precStr = TSDB_TIME_PRECISION_MILLI_STR;




1,624,013✔





3134



      break;




1,624,013✔





3135



    case TSDB_TIME_PRECISION_MICRO:




13,079✔





3136



      precStr = TSDB_TIME_PRECISION_MICRO_STR;




13,079✔





3137



      break;




13,079✔





3138



    case TSDB_TIME_PRECISION_NANO:




34,770✔





3139



      precStr = TSDB_TIME_PRECISION_NANO_STR;




34,770✔





3140



      break;




34,770✔





3141



    default:




×







3142



      precStr = "none";




×







3143



      break;




×







3144



  }










3145



  char precVstr[10] = {0};




1,671,862✔





3146



  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);




1,671,862✔





3147












3148



  char *statusStr = "ready";




1,671,862✔





3149



  if (objStatus == SDB_STATUS_CREATING) {




1,671,862✔





3150



    statusStr = "creating";




×







3151



  } else if (objStatus == SDB_STATUS_DROPPING) {




1,671,862✔





3152



    statusStr = "dropping";




×







3153



  } else {










3154



    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {




1,671,862✔





3155



      statusStr = "unsynced";




2,116✔





3156



    }










3157



  }










3158



  char statusVstr[24] = {0};




1,671,862✔





3159



  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);




1,671,862✔





3160












3161



  if (sysDb || !sysinfo) {




1,671,862✔





3162



    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {




44,044,496✔





3163



      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);




42,995,802✔





3164



      if (i == 0) {




42,995,965✔





3165



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




1,048,694✔





3166



      } else if (i == 1) {




41,947,271✔





3167



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




1,048,694✔





3168



      } else if (i == 3) {




40,898,577✔





3169



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




1,048,694✔





3170



      } else if (i == 14) {




39,849,883✔





3171



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);




1,048,694✔





3172



      } else if (i == 15) {




38,801,189✔





3173



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);




1,048,694✔





3174



      } else if (i == 28) {




37,752,495✔





3175



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




1,048,694✔





3176



      } else {










3177



        colDataSetNULL(pColInfo, rows);




36,703,801✔





3178



      }










3179



    }










3180



  } else {










3181



    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3182



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




623,168✔





3183












3184



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3185



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




623,168✔





3186












3187



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3188



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);




623,168✔





3189












3190



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3191



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




623,168✔





3192












3193



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3194



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);




623,168✔





3195












3196



    const char *strictStr = pDb->cfg.strict ? "on" : "off";




623,168✔





3197



    char        strictVstr[24] = {0};




623,168✔





3198



    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);




623,168✔





3199



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3200



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);




623,168✔





3201












3202



    char    durationStr[128] = {0};




623,168✔





3203



    char    durationVstr[128] = {0};




623,168✔





3204



    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,




623,168✔





3205



                                       pDb->cfg.daysPerFile);










3206












3207



    varDataSetLen(durationVstr, len);




623,168✔





3208



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3209



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




623,168✔





3210












3211



    char keepVstr[128] = {0};




623,168✔





3212



    char keep0Str[32] = {0};




623,168✔





3213



    char keep1Str[32] = {0};




623,168✔





3214



    char keep2Str[32] = {0};




623,168✔





3215












3216



    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);




623,168✔





3217



    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);




623,168✔





3218



    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);




623,168✔





3219












3220



    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {




623,168✔





3221



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep1Str,




×







3222



                     keep2Str, keep0Str);










3223



    } else {










3224



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep0Str,




623,168✔





3225



                     keep1Str, keep2Str);










3226



    }










3227



    varDataSetLen(keepVstr, len);




623,168✔





3228



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3229



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);




623,168✔





3230












3231



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3232



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);




623,168✔





3233












3234



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3235



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);




623,168✔





3236












3237



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3238



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);




623,168✔





3239












3240



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3241



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);




623,168✔





3242












3243



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3244



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);




623,168✔





3245












3246



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3247



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);




623,168✔





3248












3249



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3250



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);




623,168✔





3251












3252



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3253



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);




623,168✔





3254












3255



    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);




623,168✔





3256



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3257



    if (rentensionVstr == NULL) {




623,168✔





3258



      colDataSetNULL(pColInfo, rows);




623,168✔





3259



    } else {










3260



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false), &lino, _OVER);




×







3261



      taosMemoryFree(rentensionVstr);




×







3262



    }










3263












3264



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3265



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);




623,168✔





3266












3267



    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);




623,168✔





3268



    char        cacheModelVstr[24] = {0};




623,168✔





3269



    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);




623,168✔





3270



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3271



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);




623,168✔





3272












3273



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3274



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);




623,168✔





3275












3276



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3277



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastShardBits, false), &lino, _OVER);




623,168✔





3278












3279



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3280



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);




623,168✔





3281












3282



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3283



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);




623,168✔





3284












3285



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3286



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);




623,168✔





3287












3288



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3289



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);




623,168✔





3290












3291



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3292



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);




623,168✔





3293












3294



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3295



    int16_t hashPrefix = pDb->cfg.hashPrefix;




623,168✔





3296



    if (hashPrefix > 0) {




623,168✔





3297



      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;




4,940✔





3298



    } else if (hashPrefix < 0) {




618,228✔





3299



      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;




5,544✔





3300



    }










3301



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);




623,168✔





3302












3303



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3304



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);




623,168✔





3305












3306



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3307



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);




623,168✔





3308












3309



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3310



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




623,168✔





3311












3312



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3313



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssChunkSize, false), &lino, _OVER);




623,168✔





3314












3315



    char keeplocalVstr[128] = {0};




623,168✔





3316



    len = snprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr) - VARSTR_HEADER_SIZE, "%dm",




623,168✔





3317



                   pDb->cfg.ssKeepLocal);










3318



    varDataSetLen(keeplocalVstr, len);




623,168✔





3319



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3320



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);




623,168✔





3321












3322



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3323



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssCompact, false), &lino, _OVER);




623,168✔





3324












3325



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3326



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);




623,168✔





3327












3328



    char encryptAlgorithmStr[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




623,168✔





3329



    getEncryptAlgorithmStr(pMnode, pDb->cfg.encryptAlgorithm, encryptAlgorithmStr);




623,168✔





3330



    char        encryptAlgorithmVStr[24] = {0};




623,168✔





3331



    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);




623,168✔





3332



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




623,168✔





3333



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);




623,168✔





3334












3335



    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));




623,168✔





3336



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




623,168✔





3337



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3338



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




623,168✔





3339



    }










3340












3341



    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);




623,168✔





3342



    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));




623,168✔





3343



    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));




623,168✔





3344



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




623,168✔





3345



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3346



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




623,168✔





3347



    }










3348












3349



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));




623,168✔





3350



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




623,168✔





3351



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3352



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




623,168✔





3353



    }










3354












3355



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3356



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.isAudit, false), &lino, _OVER);




623,168✔





3357



    }










3358












3359



    if (!(*ppUidNames)) {




623,168✔





3360



      TAOS_CHECK_GOTO(mndBuildUidNamesHash(pMnode, ppUidNames), &lino, _OVER);




351,001✔





3361



    }










3362



    const char *ownerName = tSimpleHashGet(*ppUidNames, (const char *)&pDb->ownerId, sizeof(pDb->ownerId));




623,168✔





3363



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%s", ownerName ? ownerName : "[unknown]"));




623,168✔





3364



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




623,168✔





3365



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3366



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




623,168✔





3367



    }










3368












3369



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




623,168✔





3370



      uint8_t allowDrop = pDb->cfg.allowDrop;




623,168✔





3371



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&allowDrop, false), &lino, _OVER);




623,168✔





3372



    }










3373



  }










3374



_OVER:




1,671,862✔





3375



  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));




1,671,862✔





3376



  taosMemoryFree(buf);




1,671,862✔





3377



}










3378












3379



static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




521,806✔





3380



  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));




521,806✔





3381



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




521,806✔





3382



  pDbObj->cfg.numOfVgroups = 0;




521,806✔





3383



  pDbObj->cfg.strict = 1;




521,806✔





3384



  pDbObj->cfg.replications = 1;




521,806✔





3385



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




521,806✔





3386



}




521,806✔





3387












3388



static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




521,806✔





3389



  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));




521,806✔





3390



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




521,806✔





3391



  pDbObj->cfg.numOfVgroups = 0;




521,806✔





3392



  pDbObj->cfg.strict = 1;




521,806✔





3393



  pDbObj->cfg.replications = 1;




521,806✔





3394



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




521,806✔





3395



}




521,806✔





3396












3397



static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {




5,192,158✔





3398



  SVgObj  *pVgroup = pObj;




5,192,158✔





3399



  int32_t *numOfTables = p1;




5,192,158✔





3400



  int64_t  uid = *(int64_t *)p2;




5,192,158✔





3401



  if (pVgroup->dbUid == uid) {




5,192,158✔





3402



    *numOfTables += pVgroup->numOfTables;




1,665,757✔





3403



  }










3404



  return true;




5,192,158✔





3405



}










3406












3407



static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {




521,806✔





3408



  SMnode    *pMnode = pReq->info.node;




521,806✔





3409



  SSdb      *pSdb = pMnode->pSdb;




521,806✔





3410



  int32_t    numOfRows = 0;




521,806✔





3411



  SDbObj    *pDb = NULL;




521,806✔





3412



  SUserObj  *pOperUser = NULL;




521,806✔





3413



  ESdbStatus objStatus = 0;




521,806✔





3414



  SSHashObj *pUidNames = NULL;




521,806✔





3415












3416



  (void)mndAcquireUser(pMnode, RPC_MSG_USER(pReq), &pOperUser);




521,806✔





3417



  if (pOperUser == NULL) return 0;




521,806✔





3418



  bool sysinfo = pOperUser->sysInfo;




521,806✔





3419



  char objFName[TSDB_OBJ_FNAME_LEN + 1] = {0};




521,806✔





3420



  (void)snprintf(objFName, sizeof(objFName), "%d.*", pOperUser->acctId);




521,806✔





3421



  bool showAnyDb = (0 == mndCheckSysObjPrivilege(pMnode, pOperUser, RPC_MSG_TOKEN(pReq), PRIV_CM_SHOW, PRIV_OBJ_DB, 0,




521,806✔





3422



                                                 objFName, NULL));










3423












3424



  // Append the information_schema database into the result.










3425



  if (!pShow->sysDbRsp) {




521,806✔





3426



    SDbObj infoschemaDb = {0};




521,806✔





3427



    setInformationSchemaDbCfg(pMnode, &infoschemaDb);




521,806✔





3428



    size_t numOfTables = 0;




521,806✔





3429



    getVisibleInfosTablesNum(sysinfo, &numOfTables);




521,806✔





3430



    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




521,806✔





3431












3432



    numOfRows += 1;




521,806✔





3433












3434



    SDbObj perfschemaDb = {0};




521,806✔





3435



    setPerfSchemaDbCfg(pMnode, &perfschemaDb);




521,806✔





3436



    numOfTables = 0;




521,806✔





3437



    getPerfDbMeta(NULL, &numOfTables);




521,806✔





3438



    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




521,806✔





3439












3440



    numOfRows += 1;




521,806✔





3441



    pShow->sysDbRsp = true;




521,806✔





3442



  }










3443












3444



  while (numOfRows < rowsCapacity) {




1,150,056✔





3445



    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);




1,150,056✔





3446



    if (pShow->pIter == NULL) break;




1,150,056✔





3447



    if (showAnyDb || mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SHOW_DATABASES, pDb) == 0) {




628,250✔





3448



      int32_t numOfTables = 0;




628,250✔





3449



      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);




628,250✔





3450



      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo, &pUidNames);




628,250✔





3451



      numOfRows++;




628,250✔





3452



    }










3453












3454



    sdbRelease(pSdb, pDb);




628,250✔





3455



  }










3456












3457



  pShow->numOfRows += numOfRows;




521,806✔





3458



  mndReleaseUser(pMnode, pOperUser);




521,806✔





3459



  tSimpleHashCleanup(pUidNames);




521,806✔





3460



  return numOfRows;




521,806✔





3461



}










3462












3463



static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {




×







3464



  SSdb *pSdb = pMnode->pSdb;




×







3465



  sdbCancelFetchByType(pSdb, pIter, SDB_DB);




×







3466



}




×





















    

  • 

    •