taosdata / TDengine / #5009

coverage: 72.26% (+0.02%) from 72.241%
#5009

push

travis-ci

web-flow 
refactor: do some internal refactor for TDgpt. (#34955)

253662 of 351039 relevant lines covered (72.26%)

131649114.75 hits per line

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

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




459,079✔





77



  SSdbTable table = {




459,079✔





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




459,079✔





89



  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);




459,079✔





90



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);




459,079✔





91



  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);




459,079✔





92



  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);




459,079✔





93



  mndSetMsgHandle(pMnode, TDMT_MND_SCAN_DB, mndProcessScanDbReq);




459,079✔





94



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);




459,079✔





95



  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB_WAL, mndProcessTrimDbWalReq);




459,079✔





96



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);




459,079✔





97



  mndSetMsgHandle(pMnode, TDMT_MND_SSMIGRATE_DB, mndProcessSsMigrateDbReq);




459,079✔





98



  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);




459,079✔





99












100



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);




459,079✔





101



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);




459,079✔





102












103



  return sdbSetTable(pMnode->pSdb, table);




459,079✔





104



}










105












106



void mndCleanupDb(SMnode *pMnode) {}




459,016✔





107












108



SSdbRaw *mndDbActionEncode(SDbObj *pDb) {




6,392,958✔





109



  int32_t code = 0;




6,392,958✔





110



  int32_t lino = 0;




6,392,958✔





111



  terrno = TSDB_CODE_OUT_OF_MEMORY;




6,392,958✔





112












113



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




6,392,958✔





114



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




6,392,958✔





115



  if (pRaw == NULL) goto _OVER;




6,392,958✔





116












117



  int32_t dataPos = 0;




6,392,958✔





118



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




6,392,958✔





119



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




6,392,958✔





120



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




6,392,958✔





121



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




6,392,958✔





122



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




6,392,958✔





123



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




6,392,958✔





124



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




6,392,958✔





125



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




6,392,958✔





126



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




6,392,958✔





127



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




6,392,958✔





128



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




6,392,958✔





129



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




6,392,958✔





130



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




6,392,958✔





131



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




6,392,958✔





132



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




6,392,958✔





133



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




6,392,958✔





134



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




6,392,958✔





135



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




6,392,958✔





136



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




6,392,958✔





137



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




6,392,958✔





138



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




6,392,958✔





139



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




6,392,958✔





140



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




6,392,958✔





141



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




6,392,958✔





142



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




6,392,958✔





143



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




6,392,958✔





144



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




6,392,958✔





145



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




6,392,958✔





146



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




6,392,958✔





147



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




6,392,958✔





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,392,958✔





155



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




6,392,958✔





156



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




6,392,958✔





157



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




6,392,958✔





158



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




6,392,958✔





159



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




6,392,958✔





160



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




6,392,958✔





161



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




6,392,958✔





162



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




6,392,958✔





163



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




6,392,958✔





164



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




6,392,958✔





165



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




6,392,958✔





166



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




6,392,958✔





167



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




6,392,958✔





168



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




6,392,958✔





169



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




6,392,958✔





170



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




6,392,958✔





171



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




6,392,958✔





172



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




6,392,958✔





173



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




6,392,958✔





174



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




6,392,958✔





175



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




6,392,958✔





176



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




6,392,958✔





177



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




6,392,958✔





178












179



  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




6,392,958✔





180



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




6,392,958✔





181



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




6,392,958✔





182












183



  SDB_SET_DATALEN(pRaw, dataPos, _OVER)




6,392,958✔





184












185



  terrno = 0;




6,392,958✔





186












187



_OVER:




6,392,958✔





188



  if (terrno != 0) {




6,392,958✔





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,392,958✔





195



  return pRaw;




6,392,958✔





196



}










197












198



static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {




5,771,453✔





199



  int32_t code = 0;




5,771,453✔





200



  int32_t lino = 0;




5,771,453✔





201



  terrno = TSDB_CODE_OUT_OF_MEMORY;




5,771,453✔





202



  SSdbRow *pRow = NULL;




5,771,453✔





203



  SDbObj  *pDb = NULL;




5,771,453✔





204












205



  int8_t sver = 0;




5,771,453✔





206



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




5,771,453✔





207












208



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




5,771,453✔





209



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







210



    goto _OVER;




×







211



  }










212












213



  pRow = sdbAllocRow(sizeof(SDbObj));




5,771,453✔





214



  if (pRow == NULL) goto _OVER;




5,771,453✔





215












216



  pDb = sdbGetRowObj(pRow);




5,771,453✔





217



  if (pDb == NULL) goto _OVER;




5,771,453✔





218












219



  int32_t dataPos = 0;




5,771,453✔





220



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




5,771,453✔





221



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




5,771,453✔





222



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




5,771,453✔





223



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




5,771,453✔





224



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




5,771,453✔





225



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




5,771,453✔





226



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




5,771,453✔





227



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




5,771,453✔





228



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




5,771,453✔





229



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




5,771,453✔





230



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




5,771,453✔





231



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




5,771,453✔





232



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




5,771,453✔





233



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




5,771,453✔





234



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




5,771,453✔





235



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




5,771,453✔





236



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




5,771,453✔





237



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




5,771,453✔





238



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




5,771,453✔





239



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




5,771,453✔





240



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




5,771,453✔





241



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




5,771,453✔





242



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




5,771,453✔





243



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




5,771,453✔





244



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




5,771,453✔





245



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




5,771,453✔





246



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




5,771,453✔





247



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




5,771,453✔





248



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




5,771,453✔





249



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




5,771,453✔





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)




5,771,453✔





264



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




5,771,453✔





265



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




5,771,453✔





266



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




5,771,453✔





267



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




5,771,453✔





268



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




5,771,453✔





269



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




5,771,453✔





270



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




5,771,453✔





271



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




5,771,453✔





272



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




5,771,453✔





273



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




5,771,453✔





274



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




5,771,453✔





275



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




5,771,453✔





276



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




5,771,453✔





277



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




5,771,453✔





278



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




5,771,453✔





279



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




5,771,453✔





280



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




5,771,453✔





281



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




5,771,453✔





282



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




5,771,453✔





283



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




5,771,453✔





284



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




5,771,453✔





285



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




5,771,453✔





286



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




5,771,453✔





287












288



  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)




5,771,453✔





289



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




5,771,453✔





290



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




5,771,453✔





291



  }










292



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




5,771,453✔





293



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




5,771,453✔





294



  }










295












296



  taosInitRWLatch(&pDb->lock);




5,771,453✔





297












298



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




5,771,453✔





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




5,771,453✔





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




5,771,453✔





311



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




5,771,453✔





312



          TSDB_DEFAULT_TSDB_PAGESIZE);










313



  }










314












315



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




5,771,453✔





316



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




5,638,670✔





317



  }










318












319



  if (sver < DB_VER_SUPPORT_ADVANCED_SECURITY) {




5,771,453✔





320



    pDb->cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




×







321



  }










322












323



  terrno = 0;




5,771,453✔





324












325



_OVER:




5,771,453✔





326



  if (terrno != 0) {




5,771,453✔





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




5,771,453✔





333



  return pRow;




5,771,453✔





334



}










335












336



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




1,319,502✔





337



  SSdb    *pSdb = pMnode->pSdb;




1,319,502✔





338



  SSdbRow *pRow = NULL;




1,319,502✔





339



  SDbObj  *pNewDb = NULL;




1,319,502✔





340



  int      code = -1;




1,319,502✔





341












342



  pRow = mndDbActionDecode(pRaw);




1,319,502✔





343



  if (pRow == NULL) {




1,319,502✔





344



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







345



    if (terrno != 0) code = terrno;




×







346



    goto _OVER;




×







347



  }










348



  pNewDb = sdbGetRowObj(pRow);




1,319,502✔





349



  if (pNewDb == NULL) {




1,319,502✔





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,319,502✔





356



  if (pOldDb != NULL) {




1,319,502✔





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,319,502✔





365



_OVER:




1,319,502✔





366



  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);




1,319,502✔





367



  taosMemoryFreeClear(pRow);




1,319,502✔





368



  return code;




1,319,502✔





369



}










370












371



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




1,476,942✔





372



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




1,476,942✔





373



  return 0;




1,476,942✔





374



}










375












376



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




5,771,453✔





377



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




5,771,453✔





378



  taosArrayDestroy(pDb->cfg.pRetensions);




5,771,453✔





379



  return 0;




5,771,453✔





380



}










381












382



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




2,273,606✔





383



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




2,273,606✔





384



  taosWLockLatch(&pOld->lock);




2,273,606✔





385



  pOld->updateTime = pNew->updateTime;




2,273,606✔





386



  pOld->cfgVersion = pNew->cfgVersion;




2,273,606✔





387



  pOld->vgVersion = pNew->vgVersion;




2,273,606✔





388



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




2,273,606✔





389



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




2,273,606✔





390



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




2,273,606✔





391



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




2,273,606✔





392



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




2,273,606✔





393



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




2,273,606✔





394



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




2,273,606✔





395



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




2,273,606✔





396



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




2,273,606✔





397



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




2,273,606✔





398



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




2,273,606✔





399



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




2,273,606✔





400



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




2,273,606✔





401



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




2,273,606✔





402



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




2,273,606✔





403



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




2,273,606✔





404



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




2,273,606✔





405



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




2,273,606✔





406



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




2,273,606✔





407



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




2,273,606✔





408



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




2,273,606✔





409



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




2,273,606✔





410



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




2,273,606✔





411



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




2,273,606✔





412



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




2,273,606✔





413



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




2,273,606✔





414



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




2,273,606✔





415



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




2,273,606✔





416



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




2,273,606✔





417



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




2,273,606✔





418



  pOld->compactStartTime = pNew->compactStartTime;




2,273,606✔





419



  pOld->tsmaVersion = pNew->tsmaVersion;




2,273,606✔





420



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




2,273,606✔





421



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




2,273,606✔





422



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




2,273,606✔





423



  pOld->ownerId = pNew->ownerId;




2,273,606✔





424



  taosWUnLockLatch(&pOld->lock);




2,273,606✔





425



  return 0;




2,273,606✔





426



}










427












428



static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {




9,384,821✔





429



  SSdb *pSdb = pMnode->pSdb;




9,384,821✔





430



  return sdbGetTableVer(pSdb, SDB_VGROUP);




9,384,821✔





431



}










432












433



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




96,267,292✔





434



  SSdb   *pSdb = pMnode->pSdb;




96,267,292✔





435



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




96,267,292✔





436



  if (pDb == NULL) {




96,267,292✔





437



    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {




3,311,145✔





438



      terrno = TSDB_CODE_MND_DB_NOT_EXIST;




3,153,295✔





439



    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {




157,850✔





440



      terrno = TSDB_CODE_MND_DB_IN_CREATING;




3,079✔





441



    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {




154,771✔





442



      terrno = TSDB_CODE_MND_DB_IN_DROPPING;




154,771✔





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;




96,267,292✔





449



}










450












451



SDbObj *mndAcquireAuditDb(SMnode *pMnode) {




46,989,629✔





452



  SSdb      *pSdb = pMnode->pSdb;




46,989,629✔





453



  SDbObj    *pDb = NULL;




46,989,629✔





454



  void      *pIter = NULL;




46,989,629✔





455



  ESdbStatus objStatus = 0;




46,989,629✔





456












457



  while (1) {










458



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




130,239,975✔





459



    if (pIter == NULL) break;




130,239,975✔





460



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




83,252,390✔





461



      sdbCancelFetch(pSdb, pIter);




2,044✔





462



      break;




2,044✔





463



    }










464












465



    sdbRelease(pSdb, pDb);




83,250,346✔





466



  }










467



  return pDb;




46,989,629✔





468



}










469












470



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




105,427,821✔





471



  SSdb *pSdb = pMnode->pSdb;




105,427,821✔





472



  sdbRelease(pSdb, pDb);




105,428,096✔





473



}




105,428,096✔





474












475



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




218,402✔





476



  SDbObj *pDb = mndAcquireDb(pMnode, db);




218,402✔





477



  if (pDb == NULL) {




218,402✔





478



    return false;




1,234✔





479



  } else {










480



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




217,168✔





481



    mndReleaseDb(pMnode, pDb);




217,168✔





482



    pDb = NULL;




217,168✔





483



    return result;




217,168✔





484



  }










485



}










486












487



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




1,287,700✔





488



  char *pos = strstr(dbName, TS_PATH_DELIMITER);




1,287,700✔





489



  if (pos == NULL) {




1,287,700✔





490



    return TSDB_CODE_MND_INVALID_DB;




×







491



  }










492












493



  int32_t acctId;




1,285,420✔





494



  int32_t code = taosStr2int32(dbName, &acctId);




1,287,700✔





495



  if (code != 0) {




1,287,700✔





496



    return code;




×







497



  }










498












499



  if (acctId != pUser->acctId) {




1,287,700✔





500



    return TSDB_CODE_MND_INVALID_DB_ACCT;




×







501



  }










502












503



  return 0;




1,287,700✔





504



}










505












506



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




1,287,700✔





507



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




1,287,700✔





508












509



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




1,287,700✔





510



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




1,287,700✔





511



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




1,287,700✔





512



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




1,287,700✔





513



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




1,287,700✔





514



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




1,287,700✔





515



  if (pCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




1,287,700✔





516



      pCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




1,286,174✔





517



    return code;




3,815✔





518



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




1,283,885✔





519



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




1,283,885✔





520



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




1,283,885✔





521



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




1,283,885✔





522



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




1,283,885✔





523



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




1,283,885✔





524



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




1,283,885✔





525



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




1,283,885✔





526



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




1,283,885✔





527



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




1,283,885✔





528



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




1,283,885✔





529



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




1,283,122✔





530



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




1,283,122✔





531



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




1,283,122✔





532



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




1,283,122✔





533



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




1,283,122✔





534



#ifdef TD_ENTERPRISE










535



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




1,283,122✔





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,283,122✔





543



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




1,283,122✔





544



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




1,283,122✔





545



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




1,283,122✔





546



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




1,283,122✔





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,283,122✔





551



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




1,283,122✔





552



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




1,283,122✔





553



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




1,283,122✔





554



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




1,283,122✔





555



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




1,283,122✔





556



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




1,283,122✔





557



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




1,283,122✔





558



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




1,283,122✔





559



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




1,283,122✔





560



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




1,283,122✔





561












562



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




1,283,122✔





563



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




1,283,122✔





564



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




1,283,122✔





565












566



  if (pCfg->compactInterval != 0 &&




1,283,122✔





567



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




3,808✔





568



    return code;




×







569



  if (pCfg->compactStartTime != 0 &&




1,283,122✔





570



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




4,205✔





571



    return code;




×







572



  if (pCfg->compactEndTime != 0 &&




1,283,122✔





573



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




4,205✔





574



    return code;




×







575



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




1,283,122✔





576



    return code;




×







577



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




1,283,122✔





578



    return code;




×







579



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




1,283,122✔





580



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










581












582



  code = 0;




1,283,122✔





583



  TAOS_RETURN(code);




1,283,122✔





584



}










585












586



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




89,322✔





587



  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;




89,322✔





588



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




89,322✔





589



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




89,322✔





590



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




89,322✔





591



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




89,322✔





592



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




89,322✔





593



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




89,322✔





594



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




89,322✔





595



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




89,322✔





596



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




89,322✔





597



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




89,322✔





598



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




89,322✔





599



    return code;




×







600



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




89,322✔





601



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




89,322✔





602



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




89,322✔





603



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




89,322✔





604



  if (pNewCfg->cacheLastShardBits < TSDB_MIN_DB_CACHE_SHARD_BITS ||




89,322✔





605



      pNewCfg->cacheLastShardBits > TSDB_MAX_DB_CACHE_SHARD_BITS)




89,322✔





606



    return code;




×







607



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




89,322✔





608



#ifdef TD_ENTERPRISE










609



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




89,322✔





610



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




89,322✔





611



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




760✔





612



      terrno = TSDB_CODE_OPS_NOT_SUPPORT;




760✔





613



      return code;




760✔





614



    }










615



  }










616



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




88,562✔





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




88,562✔





625



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×







626



    return code;




×







627



  }










628



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




88,562✔





629



    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;




×







630



    return code;




×







631



  }










632












633



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




88,562✔





634



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




1,317✔





635



    return code;




×







636



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




88,562✔





637



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




88,562✔





638



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




88,562✔





639



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




87,802✔





640



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




87,802✔





641



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




87,802✔





642



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




87,802✔





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;




87,802✔





647



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




87,802✔





648



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




87,802✔





649












650



  if (pNewCfg->compactInterval != 0 &&




87,802✔





651



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




6,882✔





652



    return code;




×







653



  if (pNewCfg->compactStartTime != 0 &&




87,802✔





654



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




4,602✔





655



    return code;




×







656



  if (pNewCfg->compactEndTime != 0 &&




87,802✔





657



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




4,602✔





658



    return code;




×







659



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




87,802✔





660



      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)




4,602✔





661



    return code;




×







662



  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||




87,802✔





663



      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)




87,802✔





664



    return code;




×







665



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




87,802✔





666



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










667












668



  code = 0;




87,802✔





669



  TAOS_RETURN(code);




87,802✔





670



}










671












672



static void mndSetDefaultDbCfg(SDbCfg *pCfg) {




1,287,118✔





673



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




1,287,118✔





674



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




1,287,118✔





675



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




1,287,118✔





676



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




1,287,118✔





677



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




1,287,118✔





678



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




1,287,118✔





679



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




1,287,118✔





680



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




1,287,118✔





681



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




1,287,118✔





682



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




1,287,118✔





683



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




1,287,118✔





684



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




1,287,118✔





685



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




1,287,118✔





686



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




1,287,118✔





687



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




1,287,118✔





688



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




1,287,118✔





689



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




1,287,118✔





690



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




1,287,118✔





691



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




1,287,118✔





692



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




1,287,118✔





693



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




1,287,118✔





694



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




1,287,118✔





695



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




1,287,118✔





696



    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;




×







697



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




1,287,118✔





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,287,118✔





700



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




1,287,118✔





701



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




1,287,118✔





702



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




1,287,118✔





703



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




1,287,118✔





704



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




1,287,118✔





705



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




1,287,118✔





706



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




1,287,118✔





707



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




1,287,118✔





708



}




1,287,118✔





709












710



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




1,277,754✔





711



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,277,754✔





712



  if (pDbRaw == NULL) return -1;




1,277,754✔





713












714



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




1,277,754✔





715



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




1,277,754✔





716



  return 0;




1,277,754✔





717



}










718












719



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




1,277,172✔





720



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




3,997,287✔





721



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




2,720,115✔





722



  }










723



  return 0;




1,277,172✔





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,277,172✔





761



  int32_t  code = 0;




1,277,172✔





762



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,277,172✔





763



  if (pDbRaw == NULL) {




1,277,172✔





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,277,172✔





769



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));




1,277,172✔





770












771



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




3,997,287✔





772



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,720,115✔





773



    if (pVgRaw == NULL) {




2,720,115✔





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,720,115✔





779



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));




2,720,115✔





780



  }










781












782



  if (pDb->cfg.withArbitrator) {




1,277,172✔





783



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




10,773✔





784



      SVgObj   *pVgObj = pVgroups + v;




6,528✔





785



      SArbGroup arbGroup = {0};




6,528✔





786



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,528✔





787



      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));




6,528✔





788



    }










789



  }










790












791



  TAOS_RETURN(code);




1,277,172✔





792



}










793












794



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




1,277,172✔





795



                                        SUserObj *pUserDuped, SArray *pAuditOwnedDbs) {










796



  int32_t  code = 0;




1,277,172✔





797



  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);




1,277,172✔





798



  if (pDbRaw == NULL) {




1,277,172✔





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,277,172✔





804



  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));




1,277,172✔





805












806



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




3,997,287✔





807



    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);




2,720,115✔





808



    if (pVgRaw == NULL) {




2,720,115✔





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,720,115✔





814



    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));




2,720,115✔





815



  }










816












817



  if (pDb->cfg.withArbitrator) {




1,277,172✔





818



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




10,773✔





819



      SVgObj   *pVgObj = pVgroups + v;




6,528✔





820



      SArbGroup arbGroup = {0};




6,528✔





821



      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));




6,528✔





822



      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));




6,528✔





823



    }










824



  }










825












826



  if (pUserDuped) {




1,277,172✔





827



    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);




1,277,172✔





828



    if (pUserRaw == NULL) {




1,277,172✔





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,277,172✔





834



    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));




1,277,172✔





835



  }










836












837



  if(pAuditOwnedDbs) {




1,277,172✔





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,277,172✔





851



}










852












853



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




1,277,172✔





854



  int32_t code = 0;




1,277,172✔





855



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




3,997,287✔





856



    SVgObj *pVgroup = pVgroups + vg;




2,720,115✔





857












858



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




5,712,408✔





859



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




2,992,293✔





860



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




2,992,293✔





861



    }










862



  }










863












864



  TAOS_RETURN(code);




1,277,172✔





865



}










866












867



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




1,277,172✔





868



  int32_t code = 0;




1,277,172✔





869



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




3,997,287✔





870



    SVgObj *pVgroup = pVgroups + vg;




2,720,115✔





871












872



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




5,712,408✔





873



      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




2,992,293✔





874



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




2,992,293✔





875



    }










876



  }










877












878



  TAOS_RETURN(code);




1,277,172✔





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




132✔





891



  int32_t   code = 0, lino = 0;




132✔





892



  SSdb     *pSdb = pMnode->pSdb;




132✔





893



  SArray   *auditOwnedDbs = NULL;




132✔





894



  SUserObj *pUser = NULL;




132✔





895



  SUserObj  newUserObj = {0};




132✔





896



  int32_t   sysAuditLen = strlen(TSDB_ROLE_SYSAUDIT) + 1;




132✔





897



  int32_t   sysAuditLogLen = strlen(TSDB_ROLE_SYSAUDIT_LOG) + 1;




132✔





898












899



  void *pIter = NULL;




132✔





900



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




264✔





901



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




132✔





902



      sdbRelease(pSdb, pUser);




×







903



      pUser = NULL;




×







904



      continue;




×







905



    }










906



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




132✔





907



      sdbRelease(pSdb, pUser);




132✔





908



      pUser = NULL;




132✔





909



      continue;




132✔





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;




132✔





933



  auditOwnedDbs = NULL;




132✔





934



_exit:




132✔





935



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




132✔





936



  sdbRelease(pSdb, pUser);




132✔





937



  sdbCancelFetch(pSdb, pIter);




132✔





938



  mndUserFreeObj(&newUserObj);




132✔





939



  TAOS_RETURN(code);




132✔





940



}










941












942



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




1,289,278✔





943



  int32_t  code = 0;




1,289,278✔





944



  SArray  *auditOwnedDbs = NULL;




1,289,278✔





945



  SUserObj newUserObj = {0};




1,289,278✔





946



  SDbObj   dbObj = {0};




1,289,278✔





947



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




1,289,278✔





948



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




1,289,278✔





949



  dbObj.createdTime = taosGetTimestampMs();




1,289,278✔





950



  dbObj.updateTime = dbObj.createdTime;




1,289,278✔





951



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




1,289,278✔





952



  dbObj.cfgVersion = 1;




1,289,278✔





953



  dbObj.vgVersion = 1;




1,289,278✔





954



  dbObj.tsmaVersion = 1;




1,289,278✔





955



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




1,289,278✔





956



  dbObj.ownerId = pUser->uid;




1,289,278✔





957



  dbObj.cfg = (SDbCfg){




2,576,276✔





958



      .numOfVgroups = pCreate->numOfVgroups,




1,289,278✔





959



      .numOfStables = pCreate->numOfStables,




1,289,278✔





960



      .buffer = pCreate->buffer,




1,289,278✔





961



      .pageSize = pCreate->pageSize,




1,289,278✔





962



      .pages = pCreate->pages,




1,289,278✔





963



      .cacheLastSize = pCreate->cacheLastSize,




1,289,278✔





964



      .cacheLastShardBits = pCreate->cacheLastShardBits,




1,289,278✔





965



      .daysPerFile = pCreate->daysPerFile,




1,289,278✔





966



      .daysToKeep0 = pCreate->daysToKeep0,




1,289,278✔





967



      .daysToKeep1 = pCreate->daysToKeep1,




1,289,278✔





968



      .daysToKeep2 = pCreate->daysToKeep2,




1,289,278✔





969



      .keepTimeOffset = pCreate->keepTimeOffset,




1,289,278✔





970



      .minRows = pCreate->minRows,




1,289,278✔





971



      .maxRows = pCreate->maxRows,




1,289,278✔





972



      .walFsyncPeriod = pCreate->walFsyncPeriod,




1,289,278✔





973



      .walLevel = pCreate->walLevel,




1,289,278✔





974



      .precision = pCreate->precision,




1,289,278✔





975



      .compression = pCreate->compression,




1,289,278✔





976



      .replications = pCreate->replications,




1,289,278✔





977



      .strict = pCreate->strict,




1,289,278✔





978



      .cacheLast = pCreate->cacheLast,




1,289,278✔





979



      .hashMethod = 1,










980



      .schemaless = pCreate->schemaless,




1,289,278✔





981



      .walRetentionPeriod = pCreate->walRetentionPeriod,




1,289,278✔





982



      .walRetentionSize = pCreate->walRetentionSize,




1,289,278✔





983



      .walRollPeriod = pCreate->walRollPeriod,




1,289,278✔





984



      .walSegmentSize = pCreate->walSegmentSize,




1,289,278✔





985



      .sstTrigger = pCreate->sstTrigger,




1,289,278✔





986



      .hashPrefix = pCreate->hashPrefix,




1,289,278✔





987



      .hashSuffix = pCreate->hashSuffix,




1,289,278✔





988



      .ssChunkSize = pCreate->ssChunkSize,




1,289,278✔





989



      .ssKeepLocal = pCreate->ssKeepLocal,




1,289,278✔





990



      .ssCompact = pCreate->ssCompact,




1,289,278✔





991



      .tsdbPageSize = pCreate->tsdbPageSize,




1,289,278✔





992



      .withArbitrator = pCreate->withArbitrator,




1,289,278✔





993



      .encryptAlgorithm = pCreate->encryptAlgorithm,




1,289,278✔





994



      .compactInterval = pCreate->compactInterval,




1,289,278✔





995



      .compactStartTime = pCreate->compactStartTime,




1,289,278✔





996



      .compactEndTime = pCreate->compactEndTime,




1,289,278✔





997



      .compactTimeOffset = pCreate->compactTimeOffset,




1,289,278✔





998



      .isAudit = pCreate->isAudit,




1,289,278✔





999



      .secureDelete = pCreate->secureDelete,




1,289,278✔





1000



  };










1001



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




1,289,278✔





1002



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




6,768✔





1003



      if (pCreate->isAudit == 1) {




3,705✔





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,705✔





1010



    } else {










1011



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




3,063✔





1012



      if (pEncryptAlgr != NULL) {




3,063✔





1013



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




2,273✔





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,273✔





1020



      } else {










1021



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




790✔





1022



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




790✔





1023



        TAOS_RETURN(code);




790✔





1024



      }










1025



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




2,273✔





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,282,510✔





1033



      code = TSDB_CODE_AUDIT_MUST_ENCRYPT;




1,370✔





1034



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




1,370✔





1035



             pCreate->encryptAlgrName);










1036



      TAOS_RETURN(code);




1,370✔





1037



    }










1038



  }










1039



  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;




1,287,118✔





1040



  dbObj.cfg.pRetensions = pCreate->pRetensions;




1,287,118✔





1041












1042



  if (pCreate->isAudit == 1) {




1,287,118✔





1043



    if (dbObj.cfg.daysToKeep2 < 2628000) {




132✔





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




132✔





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;




132✔





1054



  } else {










1055



    dbObj.cfg.allowDrop = TSDB_DEFAULT_DB_ALLOW_DROP;




1,286,986✔





1056



  }










1057












1058



  mndSetDefaultDbCfg(&dbObj.cfg);




1,287,118✔





1059












1060



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




1,287,118✔





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,287,118✔





1066



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




4,578✔





1067



    TAOS_RETURN(code);




4,578✔





1068



  }










1069












1070



  if (dbObj.cfg.hashPrefix > 0) {




1,282,540✔





1071



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




4,866✔





1072



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




4,866✔





1073



    dbObj.cfg.hashPrefix += dbLen;




4,866✔





1074



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




1,277,674✔





1075



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




4,973✔





1076



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




4,973✔





1077



    dbObj.cfg.hashPrefix -= dbLen;




4,973✔





1078



  }










1079












1080



  SVgObj *pVgroups = NULL;




1,282,540✔





1081



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




1,282,540✔





1082



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




5,368✔





1083



    TAOS_RETURN(code);




5,368✔





1084



  }










1085












1086



  // add database privileges for user










1087



  SUserObj *pNewUserDuped = NULL;




1,277,172✔





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,277,172✔





1102



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




1,277,172✔





1103



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




132✔





1104



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




×







1105



      addOwned = true;




132✔





1106



    }










1107



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




132✔





1108



  } else {










1109



    addOwned = true;




1,277,040✔





1110



  }










1111



  if (addOwned) {




1,277,172✔





1112



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




1,277,172✔





1113



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




1,277,172✔





1114



    pNewUserDuped = &newUserObj;




1,277,172✔





1115



  }










1116



#endif










1117












1118



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




1,277,172✔





1119



  if (pTrans == NULL) {




1,277,172✔





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,277,172✔





1126












1127



  mndTransSetDbName(pTrans, dbObj.name, NULL);




1,277,172✔





1128



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




1,277,172✔





1129












1130



  void   *pIter = NULL;




1,277,172✔





1131



  STrans *exitTrans = NULL;




1,277,172✔





1132












1133



  if (!pUser->superUser) {




1,277,172✔





1134



    while (1) {










1135



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




3,571✔





1136



      if (pIter == NULL) break;




3,571✔





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,277,172✔





1151



    if (dbObj.cfg.numOfVgroups > 1) {




132✔





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,277,172✔





1158



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




1,277,172✔





1159



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




1,277,172✔





1160



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




1,277,172✔





1161



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




1,277,172✔





1162



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




1,277,172✔





1163



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




1,277,172✔





1164












1165



  if (dbObj.cfg.isAudit) {




1,277,172✔





1166



    if (tsAuditSaveInSelf) {




132✔





1167



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










1168



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




64✔





1169



    }










1170



  }










1171



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




1,277,172✔





1172












1173



_OVER:




1,277,172✔





1174



  taosMemoryFree(pVgroups);




1,277,172✔





1175



  mndUserFreeObj(&newUserObj);




1,277,172✔





1176



  taosArrayDestroyEx(auditOwnedDbs, (FDelete)mndUserFreeObj);




1,277,172✔





1177



  mndTransDrop(pTrans);




1,277,172✔





1178



  TAOS_RETURN(code);




1,277,172✔





1179



}










1180












1181



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




1,301,454✔





1182



  int32_t    code = 0;




1,301,454✔





1183



  SSdb      *pSdb = pMnode->pSdb;




1,301,454✔





1184



  SDnodeObj *pDnode = NULL;




1,301,454✔





1185



  void      *pIter = NULL;




1,301,454✔





1186












1187



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










1188



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




1,301,454✔





1189



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




×







1190



  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {




×







1191



    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1192



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




×







1193



           tsEncryptionKeyStat);










1194



    goto _exit;




×







1195



  }










1196












1197



  int64_t curMs = taosGetTimestampMs();




×







1198



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




×







1199



    bool online = false;




×







1200



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




×







1201



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




×







1202



      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;




×







1203



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




×







1204



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










1205



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










1206



             tsEncryptionKeyChksum);










1207



      sdbCancelFetch(pSdb, pIter);




×







1208



      sdbRelease(pSdb, pDnode);




×







1209



      break;




×







1210



    }










1211



    sdbRelease(pSdb, pDnode);




×







1212



  }










1213



#else










1214



  if (pReq->encryptAlgorithm != TSDB_ENCRYPT_ALGO_NONE) {










1215



    code = TSDB_CODE_MND_INVALID_DB_OPTION;










1216



    goto _exit;










1217



  }










1218



#endif










1219



_exit:




1,299,174✔





1220



  TAOS_RETURN(code);




1,301,454✔





1221



}










1222












1223



#ifndef TD_ENTERPRISE










1224



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










1225



  if (dnodeListStr[0] != 0) {










1226



    terrno = TSDB_CODE_OPS_NOT_SUPPORT;










1227



    return terrno;










1228



  } else {










1229



    return 0;










1230



  }










1231



}










1232



#endif










1233












1234



static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {




1,402,791✔





1235



  SMnode      *pMnode = pReq->info.node;




1,402,791✔





1236



  int32_t      code = -1;




1,402,791✔





1237



  int32_t      lino = 0;




1,402,791✔





1238



  SDbObj      *pDb = NULL;




1,402,791✔





1239



  SUserObj    *pUser = NULL;




1,402,791✔





1240



  SCreateDbReq createReq = {0};




1,402,791✔





1241



  SArray      *dnodeList = NULL;




1,402,791✔





1242



  int64_t      tss = taosGetTimestampMs();




1,402,791✔





1243












1244



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




1,402,791✔





1245



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




1,402,791✔





1246












1247



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




1,402,791✔





1248



#ifdef WINDOWS










1249



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










1250



    terrno = TSDB_CODE_MND_INVALID_PLATFORM;










1251



    goto _OVER;










1252



  }










1253



#endif










1254



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




1,402,791✔





1255












1256



  pDb = mndAcquireDb(pMnode, createReq.db);




1,402,791✔





1257



  if (pDb != NULL) {




1,402,791✔





1258



    if (createReq.ignoreExist) {




98,373✔





1259



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




95,966✔





1260



      code = 0;




95,966✔





1261



      goto _OVER;




95,966✔





1262



    } else {










1263



      code = TSDB_CODE_MND_DB_ALREADY_EXIST;




2,407✔





1264



      goto _OVER;




2,407✔





1265



    }










1266



  } else {










1267



    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {




1,304,418✔





1268



      code = terrno;




2,633✔





1269



      goto _OVER;




2,633✔





1270



    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {




1,301,785✔





1271



      goto _OVER;




×







1272



    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {




1,301,785✔





1273



      // continue










1274



    } else {  // TSDB_CODE_APP_ERROR










1275



      goto _OVER;




×







1276



    }










1277



  }










1278












1279



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




1,301,785✔





1280












1281



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




1,301,454✔





1282












1283



  int32_t nVnodes = createReq.numOfVgroups * createReq.replications;




1,301,454✔





1284



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




1,301,454✔





1285












1286



  if (createReq.replications == 2) {




1,301,454✔





1287



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




5,767✔





1288



  }










1289












1290



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




1,301,454✔





1291












1292



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




1,301,454✔





1293












1294



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




1,289,278✔





1295












1296



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




1,289,278✔





1297



    TAOS_CHECK_GOTO(TSDB_CODE_MND_MOUNT_NOT_EMPTY, &lino, _OVER);




×







1298



  }










1299












1300



  if (createReq.isAudit == 1) {




1,289,278✔





1301



    SDbObj *pAuditDb = mndAcquireAuditDb(pMnode);




1,502✔





1302



    if (pAuditDb != NULL) {




1,502✔





1303



      mndReleaseDb(pMnode, pAuditDb);




×







1304



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




×







1305



      TAOS_CHECK_GOTO(TSDB_CODE_AUDIT_DB_ALREADY_EXIST, &lino, _OVER);




×







1306



    }










1307



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




1,502✔





1308



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




1,502✔





1309



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




×







1310



      TAOS_CHECK_GOTO(TSDB_CODE_MND_INVALID_DB, &lino, _OVER);




×







1311



    }










1312



  }










1313












1314



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




1,289,278✔





1315



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




1,277,172✔





1316












1317



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




1,277,172✔





1318



    SName name = {0};




1,277,172✔





1319



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




1,277,172✔





1320



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




×







1321



    int64_t tse = taosGetTimestampMs();




1,277,172✔





1322



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




1,277,172✔





1323



    duration = duration / 1000;




1,277,172✔





1324



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




1,277,172✔





1325



  }










1326












1327



_OVER:




1,400,511✔





1328



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




1,402,791✔





1329



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




29,653✔





1330



  }










1331












1332



  mndReleaseDb(pMnode, pDb);




1,402,791✔





1333



  mndReleaseUser(pMnode, pUser);




1,402,791✔





1334



  tFreeSCreateDbReq(&createReq);




1,402,791✔





1335



  taosArrayDestroy(dnodeList);




1,402,791✔





1336












1337



  TAOS_RETURN(code);




1,402,791✔





1338



}










1339












1340



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




115,389✔





1341



  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;




115,389✔





1342












1343



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




115,389✔





1344



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




917✔





1345



    code = 0;




917✔





1346



  }










1347












1348



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




115,389✔





1349



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




2,370✔





1350



    code = 0;




2,370✔





1351



  }










1352












1353



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




115,389✔





1354



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




×







1355



    code = 0;




×







1356



  }










1357












1358



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




115,389✔





1359



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




×







1360



    code = 0;




×







1361



  }










1362












1363



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




115,389✔





1364



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




16,685✔





1365



    code = 0;




16,685✔





1366



  }










1367












1368



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




115,389✔





1369



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




15,924✔





1370



    code = 0;




15,924✔





1371



  }










1372












1373



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




115,389✔





1374



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




12,934✔





1375



    code = 0;




12,934✔





1376



  }










1377












1378



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




115,389✔





1379



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




3,830✔





1380



    code = 0;




3,830✔





1381



  }










1382












1383



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




115,389✔





1384



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




9,144✔





1385



    code = 0;




9,144✔





1386



  }










1387












1388



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




115,389✔





1389



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




9,133✔





1390



    code = 0;




9,133✔





1391



  }










1392












1393



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




115,389✔





1394



#if 1










1395



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1396



#else










1397



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










1398



    code = 0;










1399



#endif










1400



  }










1401












1402



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




115,389✔





1403



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




15,630✔





1404



    code = 0;




15,630✔





1405



  }










1406












1407



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




115,389✔





1408



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




2,479✔





1409



    code = 0;




2,479✔





1410



  }










1411












1412



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




115,389✔





1413



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




763✔





1414



    code = 0;




763✔





1415



  }










1416












1417



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




115,389✔





1418



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




6,577✔





1419



    pDb->vgVersion++;




6,577✔





1420



    code = 0;




6,577✔





1421



  }










1422












1423



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




115,389✔





1424



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




1,317✔





1425



    pDb->vgVersion++;




1,317✔





1426



    code = 0;




1,317✔





1427



  }










1428












1429



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




115,389✔





1430



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




1,520✔





1431



    pDb->vgVersion++;




1,520✔





1432



    code = 0;




1,520✔





1433



  }










1434












1435



  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&




115,389✔





1436



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




13,141✔





1437



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




7,439✔





1438



    pDb->vgVersion++;




7,439✔





1439



    code = 0;




7,439✔





1440



  }










1441












1442



  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&




115,389✔





1443



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




1,550✔





1444



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




760✔





1445



    pDb->vgVersion++;




760✔





1446



    code = 0;




760✔





1447



  }










1448












1449



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




115,389✔





1450



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




760✔





1451



    pDb->vgVersion++;




760✔





1452



    code = 0;




760✔





1453



  }










1454












1455



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




115,389✔





1456



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




760✔





1457



    pDb->vgVersion++;




760✔





1458



    code = 0;




760✔





1459



  }










1460












1461



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




115,389✔





1462



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




760✔





1463



    pDb->vgVersion++;




760✔





1464



    code = 0;




760✔





1465



  }










1466












1467



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




115,389✔





1468



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




5,355✔





1469



    pDb->vgVersion++;




5,355✔





1470



    code = 0;




5,355✔





1471



  }










1472












1473



  bool compactTimeRangeChanged = false;




115,389✔





1474



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




115,389✔





1475



      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||




113,065✔





1476



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




113,065✔





1477



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




4,602✔





1478



    compactTimeRangeChanged = true;




4,602✔





1479



    code = 0;




4,602✔





1480



  }










1481












1482



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




115,389✔





1483



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




113,065✔





1484



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




4,602✔





1485



    compactTimeRangeChanged = true;




4,602✔





1486



    code = 0;




4,602✔





1487



  }










1488



  if(compactTimeRangeChanged) {




115,389✔





1489



    pDb->vgVersion++;




4,602✔





1490



  }










1491












1492



  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&




115,389✔





1493



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




9,220✔





1494



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




3,828✔





1495



    pDb->vgVersion++;




3,828✔





1496



    code = 0;




3,828✔





1497



  }










1498












1499



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




115,389✔





1500



    code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1501



    return code;




×







1502



  }










1503












1504



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




115,389✔





1505



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




×







1506



    code = 0;




×







1507



  }










1508












1509



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




115,389✔





1510



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




581✔





1511



    pDb->vgVersion++;




581✔





1512



    code = 0;




581✔





1513



  }










1514












1515



  TAOS_RETURN(code);




115,389✔





1516



}










1517












1518



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




87,154✔





1519



  int32_t  code = 0;




87,154✔





1520



  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);




87,154✔





1521



  if (pRedoRaw == NULL) {




87,154✔





1522



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1523



    if (terrno != 0) code = terrno;




×







1524



    TAOS_RETURN(code);




×







1525



  }










1526



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




87,154✔





1527



    sdbFreeRaw(pRedoRaw);




×







1528



    TAOS_RETURN(code);




×







1529



  }










1530












1531



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




87,154✔





1532



    sdbFreeRaw(pRedoRaw);




×







1533



    TAOS_RETURN(code);




×







1534



  }










1535



  return 0;




87,154✔





1536



}










1537












1538



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




87,154✔





1539



  int32_t  code = 0;




87,154✔





1540



  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);




87,154✔





1541



  if (pCommitRaw == NULL) {




87,154✔





1542



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1543



    if (terrno != 0) code = terrno;




×







1544



    TAOS_RETURN(code);




×







1545



  }










1546



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




87,154✔





1547



    sdbFreeRaw(pCommitRaw);




×







1548



    TAOS_RETURN(code);




×







1549



  }










1550












1551



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




87,154✔





1552



    sdbFreeRaw(pCommitRaw);




×







1553



    TAOS_RETURN(code);




×







1554



  }










1555



  TAOS_RETURN(code);




87,154✔





1556



}










1557












1558



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




87,154✔





1559



  int32_t code = 0, lino = 0;




87,154✔





1560



  SSdb   *pSdb = pMnode->pSdb;




87,154✔





1561



  void   *pIter = NULL;




87,154✔





1562



  SVgObj *pVgroup = NULL;




87,154✔





1563



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




87,154✔





1564












1565



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




87,154✔





1566












1567



  while (1) {










1568



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




623,335✔





1569



    if (pIter == NULL) break;




623,335✔





1570












1571



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




536,919✔





1572



      SVgObj newVgroup = {0};




229,371✔





1573



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




229,371✔





1574



                      _err);










1575












1576



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




228,633✔





1577



        if (pNewDb->cfg.withArbitrator) {




×







1578



          SArbGroup arbGroup = {0};




×







1579



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




×







1580



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




×







1581



        } else {










1582



          SArbGroup arbGroup = {0};




×







1583



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




×







1584



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




×







1585



        }










1586



      }










1587



    }










1588












1589



    sdbRelease(pSdb, pVgroup);




536,181✔





1590



  }










1591












1592



  taosArrayDestroy(pArray);




86,416✔





1593



  TAOS_RETURN(code);




86,416✔





1594












1595



_err:




738✔





1596



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




738✔





1597












1598



  sdbCancelFetch(pSdb, pIter);




738✔





1599



  sdbRelease(pSdb, pVgroup);




738✔





1600



  taosArrayDestroy(pArray);




738✔





1601



  TAOS_RETURN(code);




738✔





1602



}










1603












1604



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




87,802✔





1605



  int32_t code = -1;




87,802✔





1606



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




87,802✔





1607



  if (pTrans == NULL) {




87,802✔





1608



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1609



    if (terrno != 0) code = terrno;




×







1610



    TAOS_RETURN(code);




×







1611



  }










1612



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




87,802✔





1613



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




87,802✔





1614












1615



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




87,802✔





1616



  mndTransSetGroupParallel(pTrans);




87,802✔





1617



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




87,802✔





1618



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




87,226✔





1619



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




87,154✔





1620












1621



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




87,154✔





1622



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




87,154✔





1623



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




87,154✔





1624












1625



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




86,416✔





1626



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




86,416✔





1627



  code = 0;




86,416✔





1628












1629



_OVER:




87,802✔





1630



  mndTransDrop(pTrans);




87,802✔





1631



  TAOS_RETURN(code);




87,802✔





1632



}










1633












1634



static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {




118,722✔





1635



  SMnode     *pMnode = pReq->info.node;




118,722✔





1636



  int32_t     code = -1;




118,722✔





1637



  SDbObj     *pDb = NULL;




118,722✔





1638



  SAlterDbReq alterReq = {0};




118,722✔





1639



  SDbObj      dbObj = {0};




118,722✔





1640



  int64_t     tss = taosGetTimestampMs();




118,722✔





1641












1642



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




118,722✔





1643












1644



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




118,722✔





1645












1646



  pDb = mndAcquireDb(pMnode, alterReq.db);




118,722✔





1647



  if (pDb == NULL) {




118,722✔





1648



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




856✔





1649



    if (terrno != 0) code = terrno;




856✔





1650



    goto _OVER;




856✔





1651



  }










1652












1653



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




117,866✔





1654












1655



  if (alterReq.replications == 2) {




117,729✔





1656



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




760✔





1657



  }










1658












1659



  int32_t numOfTopics = 0;




117,729✔





1660



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




117,729✔





1661












1662



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




117,729✔





1663



    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;




×







1664



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




×







1665



           numOfTopics);










1666



    goto _OVER;




×







1667



  }










1668












1669



  if (pDb->cfg.isMount) {




117,729✔





1670



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×







1671



    goto _OVER;




×







1672



  }










1673












1674



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




117,729✔





1675



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




117,729✔





1676



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




×







1677



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




×







1678



  }










1679












1680



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




117,729✔





1681



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




×







1682



      code = TSDB_CODE_AUDIT_MUST_KEEPFORCE;




×







1683



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




×







1684



      goto _OVER;




×







1685



    }










1686



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




×







1687



      code = TSDB_CODE_AUDIT_MUST_WALFORCE;




×







1688



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




×







1689



      goto _OVER;




×







1690



    }










1691



    if (alterReq.isAudit == 0) {




×







1692



      code = TSDB_CODE_AUDIT_DB_NOT_ALLOW_CHANGE;




×







1693



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




×







1694



      goto _OVER;




×







1695



    }










1696



  }










1697












1698



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




117,729✔





1699



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




3,130✔





1700












1701



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




3,130✔





1702



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




790✔





1703



        code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




×







1704



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




×







1705



        goto _OVER;




×







1706



      }










1707



    } else {










1708



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




2,340✔





1709



      if (pEncryptAlgr != NULL) {




2,340✔





1710



        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {




1,550✔





1711



          code = TSDB_CODE_MNODE_ENCRYPT_TYPE_NOT_MATCH;




×







1712



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




×







1713



                 alterReq.encryptAlgrName, ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS);










1714



          goto _OVER;




×







1715



        }










1716



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




1,550✔





1717



          code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;




1,550✔





1718



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




1,550✔





1719



          goto _OVER;




1,550✔





1720



        }










1721



      } else {










1722



        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;




790✔





1723



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




790✔





1724



        goto _OVER;




790✔





1725



      }










1726



    }










1727



  }










1728












1729



  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);




115,389✔





1730



  if (code != 0) {




115,389✔





1731



    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;




26,067✔





1732



    goto _OVER;




26,067✔





1733



  }










1734












1735



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




89,322✔





1736












1737



  dbObj.cfgVersion++;




87,802✔





1738



  dbObj.updateTime = taosGetTimestampMs();




87,802✔





1739



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




87,802✔





1740












1741



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




87,802✔





1742



    // return quickly, operation executed asynchronously










1743



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




5,817✔





1744



  } else {










1745



    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




81,985✔





1746



  }










1747












1748



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




87,802✔





1749



    SName name = {0};




87,802✔





1750



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




87,802✔





1751



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




×







1752












1753



    int64_t tse = taosGetTimestampMs();




87,802✔





1754



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




87,802✔





1755



    duration = duration / 1000;




87,802✔





1756



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




87,802✔





1757



  }










1758












1759



_OVER:




118,722✔





1760



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




118,722✔





1761



    if (terrno != 0) code = terrno;




6,239✔





1762



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




6,239✔





1763



  }










1764












1765



  mndReleaseDb(pMnode, pDb);




118,722✔





1766



  taosArrayDestroy(dbObj.cfg.pRetensions);




118,722✔





1767



  tFreeSAlterDbReq(&alterReq);




118,722✔





1768












1769



  TAOS_RETURN(code);




118,722✔





1770



}










1771












1772



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




4,103,324✔





1773



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




4,103,324✔





1774



  cfgRsp->dbId = pDb->uid;




4,103,324✔





1775



  cfgRsp->ownerId = pDb->ownerId;




4,103,324✔





1776



  cfgRsp->cfgVersion = pDb->cfgVersion;




4,103,324✔





1777



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




4,103,324✔





1778



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




4,103,324✔





1779



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




4,103,324✔





1780



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




4,103,324✔





1781



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




4,103,322✔





1782



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




4,103,324✔





1783



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




4,103,324✔





1784



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




4,103,324✔





1785



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




4,103,324✔





1786



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




4,103,322✔





1787



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




4,103,324✔





1788



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




4,103,324✔





1789



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




4,103,322✔





1790



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




4,103,324✔





1791



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




4,103,324✔





1792



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




4,103,324✔





1793



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




4,103,324✔





1794



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




4,103,324✔





1795



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




4,103,324✔





1796



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




4,103,324✔





1797



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




4,103,324✔





1798



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




4,103,324✔





1799



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




4,103,324✔





1800



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




4,103,324✔





1801



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




4,103,324✔





1802



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




4,103,324✔





1803



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




4,103,324✔





1804



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




4,103,324✔





1805



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




4,103,324✔





1806



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




4,103,324✔





1807



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




4,103,324✔





1808



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




4,103,324✔





1809



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




4,103,324✔





1810



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




4,103,324✔





1811



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




4,103,324✔





1812



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




4,103,324✔





1813



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




4,103,324✔





1814



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










1815



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




4,103,324✔





1816



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




4,103,324✔





1817



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




4,103,324✔





1818



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




4,103,324✔





1819



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




4,103,324✔





1820



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




4,103,324✔





1821



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




4,103,324✔





1822



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




4,103,324✔





1823



}




4,103,324✔





1824












1825



static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {




5,027,114✔





1826



  SMnode   *pMnode = pReq->info.node;




5,027,114✔





1827



  int32_t   code = -1;




5,026,372✔





1828



  SDbObj   *pDb = NULL;




5,026,372✔





1829



  SDbCfgReq cfgReq = {0};




5,026,372✔





1830



  SDbCfgRsp cfgRsp = {0};




5,026,370✔





1831












1832



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




5,026,372✔





1833












1834



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




5,027,114✔





1835



  if (pRealDb) {




5,027,114✔





1836



    ++pRealDb;




5,027,114✔





1837



  } else {










1838



    pRealDb = &cfgReq.db[0];




×







1839



  }










1840



  if (!IS_SYS_DBNAME(pRealDb)) {




5,027,114✔





1841



    pDb = mndAcquireDb(pMnode, cfgReq.db);




4,590,761✔





1842



    if (pDb == NULL) {




4,590,761✔





1843



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




535,260✔





1844



      if (terrno != 0) code = terrno;




535,260✔





1845



      goto _OVER;




535,260✔





1846



    }










1847












1848



    char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




4,055,501✔





1849



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




4,055,501✔





1850



    mndDumpDbCfgInfo(&cfgRsp, pDb, algrId);




4,055,501✔





1851



  }










1852












1853



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




4,491,854✔





1854



  void   *pRsp = rpcMallocCont(contLen);




4,491,854✔





1855



  if (pRsp == NULL) {




4,491,854✔





1856



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1857



    if (terrno != 0) code = terrno;




×







1858



    goto _OVER;




×







1859



  }










1860












1861



  int32_t ret = 0;




4,491,854✔





1862



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




4,491,854✔





1863



    code = ret;




×







1864



    goto _OVER;




×







1865



  }










1866












1867



  pReq->info.rsp = pRsp;




4,491,854✔





1868



  pReq->info.rspLen = contLen;




4,491,854✔





1869












1870



  code = 0;




4,491,854✔





1871












1872



_OVER:




5,027,114✔





1873












1874



  tFreeSDbCfgRsp(&cfgRsp);




5,027,114✔





1875












1876



  if (code != 0) {




5,027,114✔





1877



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




535,260✔





1878



  }










1879












1880



  mndReleaseDb(pMnode, pDb);




5,027,114✔





1881












1882



  TAOS_RETURN(code);




5,027,114✔





1883



}










1884












1885



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




696,868✔





1886



  int32_t  code = 0;




696,868✔





1887



  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);




696,868✔





1888



  if (pRedoRaw == NULL) {




696,868✔





1889



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1890



    if (terrno != 0) code = terrno;




×







1891



    return -1;




×







1892



  }










1893



  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));




696,868✔





1894



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));




696,868✔





1895












1896



  SSdb *pSdb = pMnode->pSdb;




696,868✔





1897



  void *pIter = NULL;




696,868✔





1898












1899



  while (1) {




4,566✔





1900



    SArbGroup *pArbGroup = NULL;




701,434✔





1901



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




701,434✔





1902



    if (pIter == NULL) break;




701,434✔





1903












1904



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




4,566✔





1905



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




4,566✔





1906



        sdbCancelFetch(pSdb, pIter);




×







1907



        sdbRelease(pSdb, pArbGroup);




×







1908



        TAOS_RETURN(code);




×







1909



      }










1910



    }










1911












1912



    sdbRelease(pSdb, pArbGroup);




4,566✔





1913



  }










1914












1915



  TAOS_RETURN(code);




696,868✔





1916



}










1917












1918



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




696,868✔





1919



  int32_t  code = 0;




696,868✔





1920



  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);




696,868✔





1921



  if (pCommitRaw == NULL) {




696,868✔





1922



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1923



    if (terrno != 0) code = terrno;




×







1924



    return -1;




×







1925



  }










1926



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));




696,868✔





1927



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));




696,868✔





1928












1929



  SSdb *pSdb = pMnode->pSdb;




696,868✔





1930



  void *pIter = NULL;




696,868✔





1931












1932



  while (1) {




4,566✔





1933



    SArbGroup *pArbGroup = NULL;




701,434✔





1934



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




701,434✔





1935



    if (pIter == NULL) break;




701,434✔





1936












1937



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




4,566✔





1938



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




4,566✔





1939



        sdbCancelFetch(pSdb, pIter);




×







1940



        sdbRelease(pSdb, pArbGroup);




×







1941



        TAOS_RETURN(code);




×







1942



      }










1943



    }










1944












1945



    sdbRelease(pSdb, pArbGroup);




4,566✔





1946



  }










1947












1948



  while (1) {




3,488,538✔





1949



    SVgObj *pVgroup = NULL;




4,185,406✔





1950



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




4,185,406✔





1951



    if (pIter == NULL) break;




4,185,406✔





1952












1953



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




3,488,538✔





1954



      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);




1,486,133✔





1955



      if (pVgRaw == NULL) {




1,486,133✔





1956



        sdbCancelFetch(pSdb, pIter);




×







1957



        sdbRelease(pSdb, pVgroup);




×







1958



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1959



        if (terrno != 0) code = terrno;




×







1960



        TAOS_RETURN(code);




×







1961



      }










1962



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




1,486,133✔





1963



        sdbCancelFetch(pSdb, pIter);




×







1964



        sdbRelease(pSdb, pVgroup);




×







1965



        TAOS_RETURN(code);




×







1966



      }










1967



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




1,486,133✔





1968



        sdbCancelFetch(pSdb, pIter);




×







1969



        sdbRelease(pSdb, pVgroup);




×







1970



        TAOS_RETURN(code);




×







1971



      }










1972



    }










1973












1974



    sdbRelease(pSdb, pVgroup);




3,488,538✔





1975



  }










1976












1977



  while (1) {




1,175,133✔





1978



    SStbObj *pStb = NULL;




1,872,001✔





1979



    ESdbStatus status;




1,866,066✔





1980



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




1,872,001✔





1981



    if (pIter == NULL) break;




1,872,001✔





1982












1983



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




1,175,133✔





1984



      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);




589,531✔





1985



      if (pStbRaw == NULL) {




589,531✔





1986



        sdbCancelFetch(pSdb, pIter);




×







1987



        sdbRelease(pSdb, pStbRaw);




×







1988



        code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







1989



        if (terrno != 0) code = terrno;




×







1990



        return -1;




×







1991



      }










1992



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




589,531✔





1993



        sdbCancelFetch(pSdb, pIter);




×







1994



        sdbRelease(pSdb, pStbRaw);




×







1995



        return -1;




×







1996



      }










1997



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




589,531✔





1998



        sdbCancelFetch(pSdb, pIter);




×







1999



        sdbRelease(pSdb, pStbRaw);




×







2000



        return -1;




×







2001



      }










2002



    }










2003












2004



    sdbRelease(pSdb, pStb);




1,175,133✔





2005



  }










2006












2007



  TAOS_RETURN(code);




696,868✔





2008



}










2009












2010



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




1,486,133✔





2011



  int32_t code = 0;




1,486,133✔





2012



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




3,042,876✔





2013



    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;




1,556,743✔





2014



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




1,556,743✔





2015



  }










2016












2017



  TAOS_RETURN(code);




1,486,133✔





2018



}










2019












2020



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




696,868✔





2021



  int32_t code = 0;




696,868✔





2022



  SSdb   *pSdb = pMnode->pSdb;




696,868✔





2023



  void   *pIter = NULL;




696,868✔





2024












2025



  while (1) {




3,488,538✔





2026



    SVgObj *pVgroup = NULL;




4,185,406✔





2027



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




4,185,406✔





2028



    if (pIter == NULL) break;




4,185,406✔





2029












2030



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




3,488,538✔





2031



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




1,486,133✔





2032



        sdbCancelFetch(pSdb, pIter);




×







2033



        sdbRelease(pSdb, pVgroup);




×







2034



        TAOS_RETURN(code);




×







2035



      }










2036



    }










2037












2038



    sdbRelease(pSdb, pVgroup);




3,488,538✔





2039



  }










2040












2041



  TAOS_RETURN(code);




696,868✔





2042



}










2043












2044



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




1,210,100✔





2045



  int32_t    code = 0;




1,210,100✔





2046



  SDropDbRsp dropRsp = {0};




1,210,100✔





2047



  if (pDb != NULL) {




1,210,100✔





2048



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




696,290✔





2049



    dropRsp.uid = pDb->uid;




696,290✔





2050



  }










2051












2052



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




1,210,100✔





2053



  void   *pRsp = NULL;




1,210,100✔





2054



  if (useRpcMalloc) {




1,210,100✔





2055



    pRsp = rpcMallocCont(rspLen);




513,810✔





2056



  } else {










2057



    pRsp = taosMemoryMalloc(rspLen);




696,290✔





2058



  }










2059












2060



  if (pRsp == NULL) {




1,210,100✔





2061



    code = terrno;




×







2062



    TAOS_RETURN(code);




×







2063



  }










2064












2065



  int32_t ret = 0;




1,210,100✔





2066



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




1,210,100✔





2067



  *pRspLen = rspLen;




1,210,100✔





2068



  *ppRsp = pRsp;




1,210,100✔





2069



  TAOS_RETURN(code);




1,210,100✔





2070



}










2071












2072



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




696,660✔





2073



  int32_t code = -1;




696,660✔





2074












2075



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




696,660✔





2076



  if (pTrans == NULL) {




696,660✔





2077



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2078



    if (terrno != 0) code = terrno;




×







2079



    goto _OVER;




×







2080



  }










2081












2082



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




696,660✔





2083












2084



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




696,660✔





2085



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




696,660✔





2086












2087



  if (mndTopicExistsForDb(pMnode, pDb)) {




696,660✔





2088



    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;




370✔





2089



    goto _OVER;




370✔





2090



  }










2091












2092



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




696,290✔





2093



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




696,290✔





2094



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




696,290✔





2095



#ifdef TD_ENTERPRISE










2096



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




696,290✔





2097



#endif










2098



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




696,290✔





2099



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




696,290✔





2100



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




696,290✔





2101



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










2102



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




696,290✔





2103



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




696,290✔





2104












2105



  int32_t rspLen = 0;




696,290✔





2106



  void   *pRsp = NULL;




696,290✔





2107



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




696,290✔





2108



  mndTransSetRpcRsp(pTrans, pRsp, rspLen);




696,290✔





2109












2110



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




696,290✔





2111



  code = 0;




696,290✔





2112












2113



_OVER:




696,660✔





2114



  mndTransDrop(pTrans);




696,660✔





2115



  TAOS_RETURN(code);




696,660✔





2116



}










2117












2118



static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {




1,216,252✔





2119



  SMnode    *pMnode = pReq->info.node;




1,216,252✔





2120



  int32_t    code = -1;




1,216,252✔





2121



  SDbObj    *pDb = NULL;




1,216,252✔





2122



  SDropDbReq dropReq = {0};




1,216,252✔





2123



  int64_t    tss = taosGetTimestampMs();




1,216,252✔





2124












2125



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




1,216,252✔





2126












2127



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




1,216,252✔





2128












2129



  pDb = mndAcquireDb(pMnode, dropReq.db);




1,216,252✔





2130



  if (pDb == NULL) {




1,216,252✔





2131



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




517,854✔





2132



    if (terrno != 0) code = terrno;




517,854✔





2133



    int32_t ret =










2134



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




517,854✔





2135



    if (ret != 0) {




517,854✔





2136



      code = ret;




×







2137



      goto _OVER;




×







2138



    }










2139



    if (dropReq.ignoreNotExists) {




517,854✔





2140



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




513,810✔





2141



    }










2142



    goto _OVER;




517,854✔





2143



  }










2144












2145



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




698,398✔





2146



    goto _OVER;




×







2147



  }










2148












2149



  if(pDb->cfg.isMount) {




698,398✔





2150



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




578✔





2151



    goto _OVER;




578✔





2152



  }










2153












2154



  if(!pDb->cfg.allowDrop) {




697,820✔





2155



    code = TSDB_CODE_MND_DB_DROP_NOT_ALLOWED;




×







2156



    goto _OVER;




×







2157



  }










2158












2159



  SSdb *pSdb = pMnode->pSdb;




697,820✔





2160



  void *pIter = NULL;




697,820✔





2161












2162



  while (1) {




3,495,554✔





2163



    SVgObj *pVgroup = NULL;




4,193,374✔





2164



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




4,193,374✔





2165



    if (pIter == NULL) break;




4,193,374✔





2166












2167



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




3,495,554✔





2168



      bool isFound = false;




1,486,507✔





2169



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




3,043,624✔





2170



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




1,557,117✔





2171



          isFound = true;




×







2172



          break;




×







2173



        }










2174



      }










2175



      if (!isFound) {




1,486,507✔





2176



        sdbRelease(pSdb, pVgroup);




1,486,507✔





2177



        continue;




1,486,507✔





2178



      }










2179



      code = TSDB_CODE_MND_VGROUP_OFFLINE;




×







2180



      sdbCancelFetch(pSdb, pIter);




×







2181



      sdbRelease(pSdb, pVgroup);




×







2182



      goto _OVER;




×







2183



    }










2184












2185



    sdbRelease(pSdb, pVgroup);




2,009,047✔





2186



  }










2187












2188



  bool dbStream = false;




697,820✔





2189



  bool vtableStream = false;




697,820✔





2190



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




697,820✔





2191



  if (dbStream) {




697,820✔





2192



    code = TSDB_CODE_MND_STREAM_DB_IN_USE;




928✔





2193



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




928✔





2194



    goto _OVER;




928✔





2195



  }










2196












2197



  if (vtableStream && !dropReq.force) {




696,892✔





2198



    code = TSDB_CODE_MND_STREAM_VTABLE_EXITS;




232✔





2199



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




232✔





2200



    goto _OVER;




232✔





2201



  }










2202












2203



  code = mndDropDb(pMnode, pReq, pDb);




696,660✔





2204



  if (code == TSDB_CODE_SUCCESS) {




696,660✔





2205



    code = TSDB_CODE_ACTION_IN_PROGRESS;




696,290✔





2206



  }










2207












2208



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




696,660✔





2209



    SName name = {0};




696,660✔





2210



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




696,660✔





2211



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




×







2212












2213



    int64_t tse = taosGetTimestampMs();




696,660✔





2214



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




696,660✔





2215



    duration = duration / 1000;




696,660✔





2216



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




696,660✔





2217



  }










2218












2219



_OVER:




1,214,459✔





2220



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




1,216,252✔





2221



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




6,152✔





2222



  }










2223












2224



  mndReleaseDb(pMnode, pDb);




1,216,252✔





2225



  tFreeSDropDbReq(&dropReq);




1,216,252✔





2226



  TAOS_RETURN(code);




1,216,252✔





2227



}










2228












2229



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




27,407,173✔





2230



  int32_t numOfTables = 0;




27,407,173✔





2231



  int32_t vindex = 0;




27,407,173✔





2232



  SSdb   *pSdb = pMnode->pSdb;




27,407,173✔





2233












2234



  void *pIter = NULL;




27,407,173✔





2235



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




109,367,087✔





2236



    SVgObj *pVgroup = NULL;




81,959,872✔





2237



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




81,959,872✔





2238



    if (pIter == NULL) break;




81,960,594✔





2239












2240



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




81,960,594✔





2241



      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




55,239,805✔





2242



      vindex++;




55,239,805✔





2243



    }










2244












2245



    sdbRelease(pSdb, pVgroup);




81,960,552✔





2246



  }










2247












2248



  sdbCancelFetch(pSdb, pIter);




27,407,173✔





2249



  return numOfTables;




27,407,173✔





2250



}










2251












2252



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




27,722,450✔





2253



  int32_t vindex = 0;




27,722,450✔





2254



  SSdb   *pSdb = pMnode->pSdb;




27,722,450✔





2255












2256



  void *pIter = NULL;




27,722,450✔





2257



  while (1) {




57,679,562✔





2258



    SVgObj *pVgroup = NULL;




85,402,012✔





2259



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




85,402,012✔





2260



    if (pIter == NULL) break;




85,402,012✔





2261












2262



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




78,946,899✔





2263



      SVgroupInfo vgInfo = {0};




63,927,507✔





2264



      vgInfo.vgId = pVgroup->vgId;




63,927,507✔





2265



      vgInfo.hashBegin = pVgroup->hashBegin;




63,927,507✔





2266



      vgInfo.hashEnd = pVgroup->hashEnd;




63,927,507✔





2267



      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;




63,927,507✔





2268



      vgInfo.epSet.numOfEps = pVgroup->replica;




63,927,507✔





2269



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




132,081,719✔





2270



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




68,154,210✔





2271



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




68,154,212✔





2272



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




68,154,212✔





2273



        if (pDnode != NULL) {




68,154,212✔





2274



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




68,125,892✔





2275



          pEp->port = pDnode->port;




68,125,892✔





2276



        }










2277



        mndReleaseDnode(pMnode, pDnode);




68,154,212✔





2278



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




68,154,212✔





2279



          vgInfo.epSet.inUse = gid;




63,430,516✔





2280



        }










2281



      }










2282



      vindex++;




63,927,507✔





2283



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




63,927,507✔





2284



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




×







2285



      }










2286



    }










2287












2288



    sdbRelease(pSdb, pVgroup);




78,946,899✔





2289












2290



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




78,946,899✔





2291



      sdbCancelFetch(pSdb, pIter);




21,267,337✔





2292



      break;




21,267,337✔





2293



    }










2294



  }










2295



}




27,722,450✔





2296












2297



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




21,545,866✔





2298



  int32_t code = 0;




21,545,866✔





2299



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




21,545,866✔





2300



  if (pRsp->pVgroupInfos == NULL) {




21,545,866✔





2301



    code = terrno;




×







2302



    TAOS_RETURN(code);




×







2303



  }










2304












2305



  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




21,545,866✔





2306












2307



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




21,545,866✔





2308



      pReq->stateTs < pDb->stateTs) {




1,339,506✔





2309



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




20,351,628✔





2310



  }










2311












2312



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




21,545,866✔





2313



  pRsp->uid = pDb->uid;




21,545,866✔





2314



  pRsp->vgVersion = pDb->vgVersion;




21,545,866✔





2315



  pRsp->stateTs = pDb->stateTs;




21,545,866✔





2316



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




21,545,866✔





2317



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




21,545,866✔





2318



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




21,545,866✔





2319



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




21,545,866✔





2320



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




21,545,866✔





2321



  TAOS_RETURN(code);




21,545,866✔





2322



}










2323












2324



static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {




27,907,279✔





2325



  SMnode   *pMnode = pReq->info.node;




27,907,279✔





2326



  int32_t   code = -1;




27,907,279✔





2327



  SDbObj   *pDb = NULL;




27,907,279✔





2328



  SUseDbReq usedbReq = {0};




27,907,279✔





2329



  SUseDbRsp usedbRsp = {0};




27,907,279✔





2330












2331



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




27,907,279✔





2332












2333



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




27,906,583✔





2334



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




27,906,583✔





2335



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




6,163,349✔





2336



    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




6,163,349✔





2337



    if (usedbReq.vgVersion < vgVersion) {




6,163,349✔





2338



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




6,155,707✔





2339



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




6,155,707✔





2340












2341



      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);




6,155,707✔





2342



      usedbRsp.vgVersion = vgVersion++;




6,155,707✔





2343



    } else {










2344



      usedbRsp.vgVersion = usedbReq.vgVersion;




7,642✔





2345



    }










2346



    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);




6,163,349✔





2347



    code = 0;




6,163,349✔





2348



  } else {










2349



    pDb = mndAcquireDb(pMnode, usedbReq.db);




21,743,234✔





2350



    if (pDb == NULL) {




21,743,930✔





2351



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




191,309✔





2352



      usedbRsp.uid = usedbReq.dbId;




191,309✔





2353



      usedbRsp.vgVersion = usedbReq.vgVersion;




191,309✔





2354



      usedbRsp.errCode = terrno;




191,309✔





2355












2356



      code = TSDB_CODE_MND_RETURN_VALUE_NULL;




191,309✔





2357



      if (terrno != 0) code = terrno;




191,309✔





2358



      goto _OVER;




191,309✔





2359



    } else {










2360



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




21,552,621✔





2361












2362



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




21,545,866✔





2363












2364



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




21,545,866✔





2365



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










2366



      code = 0;




21,545,866✔





2367



    }










2368



  }










2369












2370



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




27,709,215✔





2371



  void   *pRsp = rpcMallocCont(contLen);




27,708,471✔





2372



  if (pRsp == NULL) {




27,708,942✔





2373



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2374



    code = -1;




×







2375



    goto _OVER;




×







2376



  }










2377












2378



  int32_t ret = 0;




27,708,942✔





2379



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




27,708,942✔





2380



    code = ret;




×







2381



    goto _OVER;




×







2382



  }










2383












2384



  pReq->info.rsp = pRsp;




27,709,215✔





2385



  pReq->info.rspLen = contLen;




27,709,215✔





2386












2387



_OVER:




27,906,994✔





2388



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




27,907,006✔





2389



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




198,064✔





2390



  }










2391












2392



  mndReleaseDb(pMnode, pDb);




27,907,006✔





2393



  tFreeSUsedbRsp(&usedbRsp);




27,907,279✔





2394












2395



  TAOS_RETURN(code);




27,907,277✔





2396



}










2397












2398



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




7,528,420✔





2399



  int32_t       code = 0;




7,528,420✔





2400



  SDbHbBatchRsp batchRsp = {0};




7,528,420✔





2401



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




7,528,420✔





2402



  if (batchRsp.pArray == NULL) {




7,528,420✔





2403



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2404



    TAOS_RETURN(code);




×







2405



  }










2406












2407



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




16,642,462✔





2408



    SDbCacheInfo *pDbCacheInfo = &pDbs[i];




9,114,042✔





2409



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




9,114,042✔





2410



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




9,114,042✔





2411



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




9,114,042✔





2412



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




9,114,042✔





2413



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




9,114,042✔





2414



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




9,114,042✔





2415












2416



    SDbHbRsp rsp = {0};




9,114,042✔





2417



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




9,114,042✔





2418



    rsp.dbId = pDbCacheInfo->dbId;




9,114,042✔





2419












2420



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




9,114,042✔





2421



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




8,577,430✔





2422



      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);




3,221,472✔





2423



      if (pDbCacheInfo->vgVersion >= vgVersion) {




3,221,472✔





2424



        continue;




2,922,436✔





2425



      }










2426












2427



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




299,406✔





2428



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




299,406✔





2429



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




299,406✔





2430












2431



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




299,406✔





2432



      rsp.useDbRsp->vgVersion = vgVersion++;




299,406✔





2433












2434



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




299,406✔





2435












2436



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




598,812✔





2437



        if (terrno != 0) code = terrno;




×







2438



        return code;




×







2439



      }










2440












2441



      continue;




299,406✔





2442



    }










2443












2444



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




5,892,570✔





2445



    if (pDb == NULL) {




5,892,570✔





2446



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




31,263✔





2447



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




31,263✔





2448



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




31,263✔





2449



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




31,263✔





2450



      rsp.useDbRsp->vgVersion = -1;




31,263✔





2451



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




62,526✔





2452



        if (terrno != 0) code = terrno;




×







2453



        return code;




×







2454



      }










2455



      continue;




31,263✔





2456



    }










2457












2458



    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);




5,861,307✔





2459












2460



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




5,861,307✔





2461



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




5,789,345✔





2462



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




4,923,424✔





2463



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




4,537,884✔





2464



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










2465



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










2466



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










2467



      mndReleaseDb(pMnode, pDb);




4,537,884✔





2468



      continue;




4,537,884✔





2469



    } else {










2470



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




1,323,423✔





2471



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










2472



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










2473



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










2474



    }










2475












2476



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




1,323,423✔





2477



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




47,823✔





2478



      char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




47,823✔





2479



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




47,823✔





2480



      mndDumpDbCfgInfo(rsp.cfgRsp, pDb, algrId);




47,823✔





2481



    }










2482












2483



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




1,323,423✔





2484



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




860,930✔





2485



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




860,930✔





2486



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




860,930✔





2487



        bool    exist = false;




860,930✔





2488



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




860,930✔





2489



        if (TSDB_CODE_SUCCESS != code) {




860,930✔





2490



          mndReleaseDb(pMnode, pDb);




2,662✔





2491



          if (code != TSDB_CODE_NEED_RETRY) {




2,662✔





2492



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




2,662✔





2493



          } else {










2494



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




×







2495



          }










2496



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




2,662✔





2497



          taosMemoryFreeClear(rsp.pTsmaRsp);




2,662✔





2498



          continue;




2,662✔





2499



        }










2500



        rsp.dbTsmaVersion = pDb->tsmaVersion;




858,268✔





2501



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




858,268✔





2502



      }










2503



    }










2504












2505



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




1,320,761✔





2506



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




1,280,103✔





2507



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




915,709✔





2508



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




915,709✔





2509



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




915,709✔





2510



        mndReleaseDb(pMnode, pDb);




×







2511



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




×







2512



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




×







2513



        taosMemoryFreeClear(rsp.pTsmaRsp);




×







2514



        continue;




×







2515



      }










2516












2517



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




915,709✔





2518



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




915,709✔





2519



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




915,709✔





2520



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




915,709✔





2521



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




915,709✔





2522



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




915,709✔





2523



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




915,709✔





2524



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




915,709✔





2525



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




915,709✔





2526



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




915,709✔





2527



    }










2528












2529



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




2,641,522✔





2530



      mndReleaseDb(pMnode, pDb);




×







2531



      if (terrno != 0) code = terrno;




×







2532



      return code;




×







2533



    }










2534



    mndReleaseDb(pMnode, pDb);




1,320,761✔





2535



  }










2536












2537



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




7,528,420✔





2538



  void   *pRsp = taosMemoryMalloc(rspLen);




7,528,420✔





2539



  if (pRsp == NULL) {




7,528,420✔





2540



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







2541



    tFreeSDbHbBatchRsp(&batchRsp);




×







2542



    return -1;




×







2543



  }










2544



  int32_t ret = 0;




7,528,420✔





2545



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




7,528,420✔





2546












2547



  *ppRsp = pRsp;




7,528,420✔





2548



  *pRspLen = rspLen;




7,528,420✔





2549












2550



  tFreeSDbHbBatchRsp(&batchRsp);




7,528,420✔





2551



  TAOS_RETURN(code);




7,528,420✔





2552



}










2553












2554



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




45,948✔





2555



                                       SArray *vgroupIds, ETsdbOpType type, ETriggerType triggerType,










2556



                                       STrimDbRsp *pRsp) {










2557



  int32_t code = 0, lino = 0;




45,948✔





2558



  SSdb   *pSdb = pMnode->pSdb;




45,948✔





2559



  void   *pIter = NULL;




45,948✔





2560












2561



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




45,948✔





2562



  TAOS_CHECK_EXIT(mndAddRetentionToTrans(pMnode, pTrans, &obj, pDb, pRsp));




45,948✔





2563












2564



  int32_t j = 0;




45,948✔





2565



  int32_t numOfVgroups = taosArrayGetSize(vgroupIds);




45,948✔





2566



  if (numOfVgroups > 0) {




45,948✔





2567



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




9,132✔





2568



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




6,849✔





2569



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




6,849✔





2570












2571



      if (pVgroup == NULL) {




6,849✔





2572



        mError("db:%s, vgroup:%" PRId64 " not exist", pDb->name, vgId);




2,283✔





2573



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




2,283✔





2574



      } else if (pVgroup->dbUid != pDb->uid) {




4,566✔





2575



        mError("db:%s, vgroup:%" PRId64 " not belong to db:%s", pDb->name, vgId, pDb->name);




×







2576



        sdbRelease(pSdb, pVgroup);




×







2577



        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);




×







2578



      }










2579



      sdbRelease(pSdb, pVgroup);




4,566✔





2580



    }










2581












2582



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




6,849✔





2583



      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);




4,566✔





2584



      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);




4,566✔





2585












2586



      if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




4,566✔





2587



        sdbRelease(pSdb, pVgroup);




×







2588



        TAOS_RETURN(code);




×







2589



      }










2590












2591



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




9,132✔





2592



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




4,566✔





2593



        if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




4,566✔





2594



          sdbRelease(pSdb, pVgroup);




×







2595



          TAOS_RETURN(code);




×







2596



        }










2597



        j++;




4,566✔





2598



      }










2599



      sdbRelease(pSdb, pVgroup);




4,566✔





2600



    }










2601



  } else {










2602



    while (1) {




253,703✔





2603



      SVgObj *pVgroup = NULL;




295,085✔





2604



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




295,085✔





2605



      if (pIter == NULL) break;




295,085✔





2606












2607



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




253,703✔





2608



        if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {




86,467✔





2609



          sdbCancelFetch(pSdb, pIter);




×







2610



          sdbRelease(pSdb, pVgroup);




×







2611



          TAOS_RETURN(code);




×







2612



        }










2613












2614



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




175,430✔





2615



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




88,963✔





2616



          if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {




88,963✔





2617



            sdbCancelFetch(pSdb, pIter);




×







2618



            sdbRelease(pSdb, pVgroup);




×







2619



            TAOS_RETURN(code);




×







2620



          }










2621



          j++;




88,963✔





2622



        }










2623



      }










2624












2625



      sdbRelease(pSdb, pVgroup);




253,703✔





2626



    }










2627



  }










2628



_exit:




45,948✔





2629



  TAOS_RETURN(code);




45,948✔





2630



}










2631












2632



static int32_t mndBuildTrimDbRsp(STrimDbRsp *rsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




43,665✔





2633



  int32_t code = 0;




43,665✔





2634



  int32_t rspLen = tSerializeSCompactDbRsp(NULL, 0, (SCompactDbRsp *)rsp);




43,665✔





2635



  void   *pRsp = NULL;




43,665✔





2636



  if (useRpcMalloc) {




43,665✔





2637



    pRsp = rpcMallocCont(rspLen);




×







2638



  } else {










2639



    pRsp = taosMemoryMalloc(rspLen);




43,665✔





2640



  }










2641












2642



  if (pRsp == NULL) {




43,665✔





2643



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2644



    TAOS_RETURN(code);




×







2645



  }










2646












2647



  (void)tSerializeSCompactDbRsp(pRsp, rspLen, (SCompactDbRsp *)rsp);




43,665✔





2648



  *pRspLen = rspLen;




43,665✔





2649



  *ppRsp = pRsp;




43,665✔





2650



  TAOS_RETURN(code);




43,665✔





2651



}










2652












2653



int32_t mndTrimDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, STimeWindow tw, SArray *vgroupIds,




50,514✔





2654



                         ETsdbOpType type, ETriggerType triggerType) {










2655



  SSdb      *pSdb = pMnode->pSdb;




50,514✔





2656



  SVgObj    *pVgroup = NULL;




50,514✔





2657



  void      *pIter = NULL;




50,514✔





2658



  int32_t    code = 0, lino = 0;




50,514✔





2659



  STrimDbRsp rsp = {0};




50,514✔





2660



  bool       isExist = false;




50,514✔





2661












2662



  while (1) {




57,176✔





2663



    SRetentionObj *pObj = NULL;




107,690✔





2664



    pIter = sdbFetch(pMnode->pSdb, SDB_RETENTION, pIter, (void **)&pObj);




107,690✔





2665



    if (pIter == NULL) break;




107,690✔





2666












2667



    if (strcmp(pObj->dbname, pDb->name) == 0) {




57,176✔





2668



      isExist = true;




4,566✔





2669



    }










2670



    sdbRelease(pMnode->pSdb, pObj);




57,176✔





2671



  }










2672



  if (isExist) {




50,514✔





2673



    mInfo("trim db:%s already exist", pDb->name);




4,566✔





2674



    TAOS_RETURN(TSDB_CODE_MND_TRIM_ALREADY_EXIST);




4,566✔





2675



  }










2676












2677



  int64_t startTs = taosGetTimestampMs();




45,948✔





2678



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




45,948✔





2679



  if (pTrans == NULL) goto _exit;




45,948✔





2680



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




45,948✔





2681



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




45,948✔





2682



  TAOS_CHECK_EXIT(mndTrancCheckConflict(pMnode, pTrans));




45,948✔





2683



  TAOS_CHECK_EXIT(mndSetTrimDbRedoActions(pMnode, pTrans, pDb, startTs, tw, vgroupIds, type, triggerType, &rsp));




45,948✔





2684



  if (pReq) {




43,665✔





2685



    int32_t rspLen = 0;




43,665✔





2686



    void   *pRsp = NULL;




43,665✔





2687



    rsp.bAccepted = true;




43,665✔





2688



    TAOS_CHECK_EXIT(mndBuildTrimDbRsp(&rsp, &rspLen, &pRsp, false));




43,665✔





2689



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




43,665✔





2690



  }










2691



  TAOS_CHECK_EXIT(mndTransPrepare(pMnode, pTrans));




43,665✔





2692



_exit:




45,948✔





2693



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




45,948✔





2694



    mError("db:%s, failed at line %d to trim db since %s", pDb->name, lino, tstrerror(code));




2,283✔





2695



  }










2696



  mndTransDrop(pTrans);




45,948✔





2697



  TAOS_RETURN(code);




45,948✔





2698



}










2699












2700



#ifdef TD_ENTERPRISE










2701



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




14,459✔





2702



  int32_t   code = 0;




14,459✔





2703



  void     *pIter = NULL;




14,459✔





2704



  SRsmaObj *pRsma = NULL;




14,459✔





2705



  while ((pIter = sdbFetch(pMnode->pSdb, SDB_RSMA, pIter, (void **)&pRsma))) {




14,459✔





2706



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




14,459✔





2707



      sdbRelease(pMnode->pSdb, pRsma);




14,459✔





2708



      sdbCancelFetch(pMnode->pSdb, pIter);




14,459✔





2709



      TAOS_RETURN(code);




14,459✔





2710



    }










2711



    sdbRelease(pMnode->pSdb, pRsma);




×







2712



  }










2713



  TAOS_RETURN(TSDB_CODE_RSMA_NOT_EXIST);




×







2714



}










2715



#endif










2716












2717



static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {




23,030✔





2718



  SMnode    *pMnode = pReq->info.node;




23,030✔





2719



  int32_t    code = 0, lino = 0;




23,030✔





2720



  SDbObj    *pDb = NULL;




23,030✔





2721



  STrimDbReq trimReq = {0};




23,030✔





2722



  int64_t    tss = taosGetTimestampMs();




23,030✔





2723












2724



  TAOS_CHECK_EXIT(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq));




23,030✔





2725












2726



  mInfo("db:%s, start to trim, optr:%u, tw:%" PRId64 ",%" PRId64, trimReq.db, trimReq.optrType, trimReq.tw.skey,




23,030✔





2727



        trimReq.tw.ekey);










2728












2729



  pDb = mndAcquireDb(pMnode, trimReq.db);




23,030✔





2730



  if (pDb == NULL) {




23,030✔





2731



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2732



    if (terrno != 0) code = terrno;




×







2733



    TAOS_CHECK_EXIT(code);




×







2734



  }










2735












2736



  TAOS_CHECK_EXIT(mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_TRIM_DB, pDb));




23,030✔





2737












2738



  if (pDb->cfg.isMount) {




23,030✔





2739



    TAOS_CHECK_EXIT(TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT);




×







2740



  }










2741












2742



#ifdef TD_ENTERPRISE










2743



  if (trimReq.optrType == TSDB_OPTR_ROLLUP) {




23,030✔





2744



    TAOS_CHECK_EXIT(mndCheckRsmaInDb(pMnode, pDb));




14,459✔





2745



  }










2746



#endif










2747












2748



  TAOS_CHECK_EXIT(mndTrimDb(pMnode, pReq, pDb, trimReq.tw, trimReq.vgroupIds, trimReq.optrType, trimReq.triggerType));




23,030✔





2749



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;




16,181✔





2750












2751



  if (tsAuditLevel >= AUDIT_LEVEL_DATABASE) {




16,181✔





2752



    SName name = {0};




16,181✔





2753



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




16,181✔





2754



      mWarn("db:%s, failed at line %d to parse db name", trimReq.db, __LINE__);




×







2755



    }










2756












2757



    char optrType[16] = {0};




16,181✔





2758



    (void)snprintf(optrType, sizeof(optrType), "%u", trimReq.optrType);




16,181✔





2759



    int64_t tse = taosGetTimestampMs();




16,181✔





2760



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




16,181✔





2761



    duration = duration / 1000;




16,181✔





2762



    auditRecord(pReq, pMnode->clusterId, "trimDB", name.dbname, optrType, trimReq.sql, trimReq.sqlLen, duration, 0);




16,181✔





2763



  }










2764












2765



_exit:




23,030✔





2766



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




23,030✔





2767



    mError("db:%s, failed at line %d to process trim db req since %s, optr:%u", trimReq.db, lino, tstrerror(code),




6,849✔





2768



           trimReq.optrType);










2769



  }










2770












2771



  mndReleaseDb(pMnode, pDb);




23,030✔





2772



  tFreeSTrimDbReq(&trimReq);




23,030✔





2773



  TAOS_RETURN(code);




23,030✔





2774



}










2775












2776



static int32_t mndBuildSsMigrateDbRsp(SSsMigrateDbRsp *pSsMigrateRsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {




2,283✔





2777



  int32_t code = 0;




2,283✔





2778



  int32_t rspLen = tSerializeSSsMigrateDbRsp(NULL, 0, pSsMigrateRsp);




2,283✔





2779



  void   *pRsp = NULL;




2,283✔





2780



  if (useRpcMalloc) {




2,283✔





2781



    pRsp = rpcMallocCont(rspLen);




×







2782



  } else {










2783



    pRsp = taosMemoryMalloc(rspLen);




2,283✔





2784



  }










2785












2786



  if (pRsp == NULL) {




2,283✔





2787



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2788



    TAOS_RETURN(code);




×







2789



  }










2790












2791



  (void)tSerializeSSsMigrateDbRsp(pRsp, rspLen, pSsMigrateRsp);




2,283✔





2792



  *pRspLen = rspLen;




2,283✔





2793



  *ppRsp = pRsp;




2,283✔





2794



  TAOS_RETURN(code);




2,283✔





2795



}










2796












2797



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




1,150✔





2798



  SSdb   *pSdb = pMnode->pSdb;




1,150✔





2799



  SVgObj *pVgroup = NULL;




1,150✔





2800



  void   *pIter = NULL;




1,150✔





2801



  int32_t code = 0;




1,150✔





2802












2803



  // Iterate through all vgroups in this database










2804



  while (1) {




2,300✔





2805



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




3,450✔





2806



    if (pIter == NULL) break;




3,450✔





2807












2808



    // Check if this vgroup belongs to the database










2809



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




2,300✔





2810



      sdbRelease(pSdb, pVgroup);




×







2811



      continue;




×







2812



    }










2813












2814



    // Prepare message to send to vnode










2815



    int32_t   contLen = sizeof(SMsgHead);




2,300✔





2816



    SMsgHead *pHead = rpcMallocCont(contLen);




2,300✔





2817



    if (pHead == NULL) {




2,300✔





2818



      sdbCancelFetch(pSdb, pVgroup);




×







2819



      sdbRelease(pSdb, pVgroup);




×







2820



      code = TSDB_CODE_OUT_OF_MEMORY;




×







2821



      break;




×







2822



    }










2823



    pHead->contLen = htonl(contLen);




2,300✔





2824



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




2,300✔





2825












2826



    // Send TRIM WAL request to vnode










2827



    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM_WAL, .pCont = pHead, .contLen = contLen};




2,300✔





2828



    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);




2,300✔





2829



    code = tmsgSendReq(&epSet, &rpcMsg);




2,300✔





2830



    if (code != 0) {




2,300✔





2831



      mError("vgId:%d, failed to send vnode-trim-wal request since 0x%x", pVgroup->vgId, code);




×







2832



    } else {










2833



      mInfo("vgId:%d, send vnode-trim-wal request to vnode", pVgroup->vgId);




2,300✔





2834



    }










2835



    sdbRelease(pSdb, pVgroup);




2,300✔





2836



  }










2837












2838



  return code;




1,150✔





2839



}










2840












2841



static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq) {




1,150✔





2842



  SMnode    *pMnode = pReq->info.node;




1,150✔





2843



  int32_t    code = -1;




1,150✔





2844



  SDbObj    *pDb = NULL;




1,150✔





2845



  STrimDbReq trimReq = {0};




1,150✔





2846












2847



  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);




1,150✔





2848












2849



  mInfo("db:%s, start to trim WAL", trimReq.db);




1,150✔





2850












2851



  pDb = mndAcquireDb(pMnode, trimReq.db);




1,150✔





2852



  if (pDb == NULL) {




1,150✔





2853



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2854



    if (terrno != 0) code = terrno;




×







2855



    goto _OVER;




×







2856



  }










2857












2858



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




1,150✔





2859












2860



  code = mndTrimDbWal(pMnode, pDb);




1,150✔





2861












2862



_OVER:




1,150✔





2863



  if (code != 0) {




1,150✔





2864



    mError("db:%s, failed to process trim db wal req since %s", trimReq.db, terrstr());




×







2865



  }










2866












2867



  mndReleaseDb(pMnode, pDb);




1,150✔





2868



  TAOS_RETURN(code);




1,150✔





2869



}










2870












2871



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




2,283✔





2872



  int32_t       code = 0;




2,283✔





2873



  SSsMigrateDbRsp ssMigrateRsp = {0};




2,283✔





2874












2875



  bool  isExist = false;




2,283✔





2876



  void *pIter = NULL;




2,283✔





2877



  while (1) {




×







2878



    SSsMigrateObj *pSsMigrate = NULL;




2,283✔





2879



    pIter = sdbFetch(pMnode->pSdb, SDB_SSMIGRATE, pIter, (void **)&pSsMigrate);




2,283✔





2880



    if (pIter == NULL) break;




2,283✔





2881












2882



    if (strcmp(pSsMigrate->dbname, pDb->name) == 0) {




×







2883



      isExist = true;




×







2884



    }










2885



    sdbRelease(pMnode->pSdb, pSsMigrate);




×







2886



  }










2887



  if (isExist) {




2,283✔





2888



    mInfo("ssmigrate db:%s already exist", pDb->name);




×







2889












2890



    if (pReq) {




×







2891



      int32_t rspLen = 0;




×







2892



      void   *pRsp = NULL;




×







2893



      ssMigrateRsp.ssMigrateId = 0;




×







2894



      ssMigrateRsp.bAccepted = false;




×







2895



      TAOS_CHECK_RETURN(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, true));




×







2896












2897



      pReq->info.rsp = pRsp;




×







2898



      pReq->info.rspLen = rspLen;




×







2899



    }










2900












2901



    return TSDB_CODE_MND_SSMIGRATE_ALREADY_EXIST;




×







2902



  }










2903












2904



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




2,283✔





2905



  if (pTrans == NULL) {




2,283✔





2906



    mError("failed to create ssmigrate-db trans since %s", terrstr());




×







2907



    goto _OVER;




×







2908



  }










2909












2910



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




2,283✔





2911



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




2,283✔





2912



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




2,283✔





2913












2914



  SSsMigrateObj ssMigrate = { .startTime = taosGetTimestampMs() };




2,283✔





2915



  TAOS_CHECK_GOTO(mndAddSsMigrateToTran(pMnode, pTrans, &ssMigrate, pDb), NULL, _OVER);




2,283✔





2916












2917



  if (pReq) {




2,283✔





2918



    int32_t rspLen = 0;




2,283✔





2919



    void   *pRsp = NULL;




2,283✔





2920



    ssMigrateRsp.ssMigrateId = ssMigrate.id;




2,283✔





2921



    ssMigrateRsp.bAccepted = true;




2,283✔





2922



    TAOS_CHECK_GOTO(mndBuildSsMigrateDbRsp(&ssMigrateRsp, &rspLen, &pRsp, false), NULL, _OVER);




2,283✔





2923



    mndTransSetRpcRsp(pTrans, pRsp, rspLen);




2,283✔





2924



  }










2925












2926



  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;




2,283✔





2927



  code = 0;




2,283✔





2928












2929



_OVER:




2,283✔





2930



  mndTransDrop(pTrans);




2,283✔





2931



  TAOS_RETURN(code);




2,283✔





2932



}










2933












2934












2935



static int32_t mndProcessSsMigrateDbReq(SRpcMsg *pReq) {




2,694✔





2936



  SMnode         *pMnode = pReq->info.node;




2,694✔





2937



  int32_t         code = -1;




2,694✔





2938



  SDbObj         *pDb = NULL;




2,694✔





2939



  SSsMigrateDbReq ssMigrateReq = {0};




2,694✔





2940












2941



  if (!tsSsEnabled) {




2,694✔





2942



    code = TSDB_CODE_OPS_NOT_SUPPORT;




411✔





2943



    goto _OVER;




411✔





2944



  }










2945












2946



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




2,283✔





2947



  TAOS_CHECK_GOTO(tDeserializeSSsMigrateDbReq(pReq->pCont, pReq->contLen, &ssMigrateReq), NULL, _OVER);




2,283✔





2948












2949



  mInfo("db:%s, start to ssmigrate", ssMigrateReq.db);




2,283✔





2950












2951



  pDb = mndAcquireDb(pMnode, ssMigrateReq.db);




2,283✔





2952



  if (pDb == NULL) {




2,283✔





2953



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







2954



    if (terrno != 0) code = terrno;




×







2955



    goto _OVER;




×







2956



  }










2957












2958



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




2,283✔





2959












2960



  if(pDb->cfg.isMount) {




2,283✔





2961



    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;




×







2962



    goto _OVER;




×







2963



  }










2964












2965



  code = mndSsMigrateDb(pMnode, pReq, pDb);




2,283✔





2966












2967



_OVER:




2,694✔





2968



  if (code != 0) {




2,694✔





2969



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




411✔





2970



  }










2971












2972



  mndReleaseDb(pMnode, pDb);




2,694✔





2973



  TAOS_RETURN(code);




2,694✔





2974



}










2975












2976



const char *mndGetDbStr(const char *src) {




19,784,195✔





2977



  char *pos = strstr(src, TS_PATH_DELIMITER);




19,784,195✔





2978



  if (pos != NULL) ++pos;




19,784,195✔





2979



  if (pos == NULL) return src;




19,784,195✔





2980



  return pos;




18,417,372✔





2981



}










2982












2983



const char *mndGetStableStr(const char *src) {




16,522,509✔





2984



  char *pos = strstr(src, TS_PATH_DELIMITER);




16,522,509✔





2985



  if (pos != NULL) ++pos;




16,522,509✔





2986



  if (pos == NULL) return src;




16,522,509✔





2987



  return mndGetDbStr(pos);




16,522,509✔





2988



}










2989












2990



static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {




×







2991



  int64_t v = 0;




×







2992



  switch (unit) {




×







2993



    case 's':




×







2994



      v = val / 1000;




×







2995



      break;




×







2996



    case 'm':




×







2997



      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];




×







2998



      break;




×







2999



    case 'h':




×







3000



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);




×







3001



      break;




×







3002



    case 'd':




×







3003



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);




×







3004



      break;




×







3005



    case 'w':




×







3006



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);




×







3007



      break;




×







3008



    default:




×







3009



      break;




×







3010



  }










3011












3012



  return v;




×







3013



}










3014












3015



static char *buildRetension(SArray *pRetension) {




581,549✔





3016



  size_t size = taosArrayGetSize(pRetension);




581,549✔





3017



  if (size == 0) {




581,549✔





3018



    return NULL;




581,549✔





3019



  }










3020












3021



  char       *p1 = taosMemoryCalloc(1, 100);




×







3022



  SRetention *p = taosArrayGet(pRetension, 0);




×







3023












3024



  int32_t len = 2;




×







3025












3026



  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3027



  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3028



  len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3029












3030



  if (size > 1) {




×







3031



    len += snprintf(p1 + len, 100 - len, ",");




×







3032



    p = taosArrayGet(pRetension, 1);




×







3033












3034



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3035



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3036



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3037



  }










3038












3039



  if (size > 2) {




×







3040



    len += snprintf(p1 + len, 100 - len, ",");




×







3041



    p = taosArrayGet(pRetension, 2);




×







3042












3043



    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







3044



    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







3045



    len += snprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







3046



  }










3047












3048



  varDataSetLen(p1, len);




×







3049



  return p1;




×







3050



}










3051












3052



static const char *getCacheModelStr(int8_t cacheModel) {




581,549✔





3053



  switch (cacheModel) {




581,549✔





3054



    case TSDB_CACHE_MODEL_NONE:




523,360✔





3055



      return TSDB_CACHE_MODEL_NONE_STR;




523,360✔





3056



    case TSDB_CACHE_MODEL_LAST_ROW:




3,504✔





3057



      return TSDB_CACHE_MODEL_LAST_ROW_STR;




3,504✔





3058



    case TSDB_CACHE_MODEL_LAST_VALUE:




7,025✔





3059



      return TSDB_CACHE_MODEL_LAST_VALUE_STR;




7,025✔





3060



    case TSDB_CACHE_MODEL_BOTH:




47,660✔





3061



      return TSDB_CACHE_MODEL_BOTH_STR;




47,660✔





3062



    default:




×







3063



      break;




×







3064



  }










3065



  return "unknown";




×







3066



}










3067












3068



static void getEncryptAlgorithmStr(SMnode *pMnode, int8_t encryptAlgorithm, char *out) {




581,549✔





3069



  switch (encryptAlgorithm) {




581,549✔





3070



    case TSDB_ENCRYPT_ALGO_NONE: {




580,568✔





3071



      tstrncpy(out, TSDB_ENCRYPT_ALGO_NONE_STR, TSDB_ENCRYPT_ALGR_NAME_LEN);




580,568✔





3072



      break;




580,568✔





3073



    }










3074



    default: {




981✔





3075



      SEncryptAlgrObj *obj = mndAcquireEncryptAlgrById(pMnode, encryptAlgorithm);




981✔





3076



      if (obj != NULL) {




981✔





3077



        tstrncpy(out, obj->algorithm_id, TSDB_ENCRYPT_ALGR_NAME_LEN);




981✔





3078



        mndReleaseEncryptAlgr(pMnode, obj);




981✔





3079



      }










3080



      break;




981✔





3081



    }










3082



  }










3083



}




581,549✔





3084












3085



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




2,201,015✔





3086



  if (pDb->cfg.replications == 1) return true;




2,201,015✔





3087












3088



  SSdb *pSdb = pMnode->pSdb;




433,906✔





3089



  void *pIter = NULL;




433,906✔





3090



  bool  isReady = true;




433,906✔





3091



  while (1) {




2,085,344✔





3092



    SVgObj *pVgroup = NULL;




2,519,250✔





3093



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




2,519,250✔





3094



    if (pIter == NULL) break;




2,519,250✔





3095












3096



    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {




2,085,344✔





3097



      bool hasLeader = false;




1,275,037✔





3098



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




5,047,589✔





3099



        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||




3,772,552✔





3100



            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {




3,330,281✔





3101



          hasLeader = true;




442,271✔





3102



        }










3103



      }










3104



      if (!hasLeader) isReady = false;




1,275,037✔





3105



    }










3106



    sdbRelease(pSdb, pVgroup);




2,085,344✔





3107



  }










3108












3109



  return isReady;




433,906✔





3110



}










3111












3112



static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,




1,574,373✔





3113



                              int64_t numOfTables, bool sysDb, ESdbStatus objStatus, bool sysinfo,










3114



                              SSHashObj **ppUidNames) {










3115



  int32_t cols = 0;




1,574,373✔





3116



  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;




1,574,373✔





3117



  char   *buf = taosMemoryMalloc(bytes);




1,574,373✔





3118



  if (buf == NULL) {




1,574,373✔





3119



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




×







3120



    return;




×







3121



  }










3122



  int32_t code = 0;




1,574,373✔





3123



  int32_t lino = 0;




1,574,373✔





3124












3125



  const char *name = mndGetDbStr(pDb->name);




1,574,373✔





3126



  if (name != NULL) {




1,574,373✔





3127



    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);




1,574,373✔





3128



  } else {










3129



    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);




×







3130



  }










3131












3132



  const char *precStr = NULL;




1,574,373✔





3133



  switch (pDb->cfg.precision) {




1,574,373✔





3134



    case TSDB_TIME_PRECISION_MILLI:




1,528,000✔





3135



      precStr = TSDB_TIME_PRECISION_MILLI_STR;




1,528,000✔





3136



      break;




1,528,000✔





3137



    case TSDB_TIME_PRECISION_MICRO:




12,550✔





3138



      precStr = TSDB_TIME_PRECISION_MICRO_STR;




12,550✔





3139



      break;




12,550✔





3140



    case TSDB_TIME_PRECISION_NANO:




33,823✔





3141



      precStr = TSDB_TIME_PRECISION_NANO_STR;




33,823✔





3142



      break;




33,823✔





3143



    default:




×







3144



      precStr = "none";




×







3145



      break;




×







3146



  }










3147



  char precVstr[10] = {0};




1,574,373✔





3148



  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);




1,574,373✔





3149












3150



  char *statusStr = "ready";




1,574,373✔





3151



  if (objStatus == SDB_STATUS_CREATING) {




1,574,373✔





3152



    statusStr = "creating";




×







3153



  } else if (objStatus == SDB_STATUS_DROPPING) {




1,574,373✔





3154



    statusStr = "dropping";




×







3155



  } else {










3156



    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {




1,574,373✔





3157



      statusStr = "unsynced";




1,193✔





3158



    }










3159



  }










3160



  char statusVstr[24] = {0};




1,574,373✔





3161



  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);




1,574,373✔





3162












3163



  if (sysDb || !sysinfo) {




1,574,373✔





3164



    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {




41,697,148✔





3165



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




40,704,324✔





3166



      if (i == 0) {




40,704,470✔





3167



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




992,824✔





3168



      } else if (i == 1) {




39,711,646✔





3169



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




992,824✔





3170



      } else if (i == 3) {




38,718,822✔





3171



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




992,824✔





3172



      } else if (i == 14) {




37,725,998✔





3173



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);




992,824✔





3174



      } else if (i == 15) {




36,733,174✔





3175



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);




992,824✔





3176



      } else if (i == 28) {




35,740,350✔





3177



        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




992,824✔





3178



      } else {










3179



        colDataSetNULL(pColInfo, rows);




34,747,526✔





3180



      }










3181



    }










3182



  } else {










3183



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




581,549✔





3184



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);




581,549✔





3185












3186



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




581,549✔





3187



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);




581,549✔





3188












3189



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




581,549✔





3190



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);




581,549✔





3191












3192



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




581,549✔





3193



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);




581,549✔





3194












3195



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




581,549✔





3196



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);




581,549✔





3197












3198



    const char *strictStr = pDb->cfg.strict ? "on" : "off";




581,549✔





3199



    char        strictVstr[24] = {0};




581,549✔





3200



    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);




581,549✔





3201



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




581,549✔





3202



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);




581,549✔





3203












3204



    char    durationStr[128] = {0};




581,549✔





3205



    char    durationVstr[128] = {0};




581,549✔





3206



    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,




581,549✔





3207



                                       pDb->cfg.daysPerFile);










3208












3209



    varDataSetLen(durationVstr, len);




581,549✔





3210



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




581,549✔





3211



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




581,549✔





3212












3213



    char keepVstr[128] = {0};




581,549✔





3214



    char keep0Str[32] = {0};




581,549✔





3215



    char keep1Str[32] = {0};




581,549✔





3216



    char keep2Str[32] = {0};




581,549✔





3217












3218



    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);




581,549✔





3219



    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);




581,549✔





3220



    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);




581,549✔





3221












3222



    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {




581,549✔





3223



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep1Str,




×







3224



                     keep2Str, keep0Str);










3225



    } else {










3226



      len = snprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr) - VARSTR_HEADER_SIZE, "%s,%s,%s", keep0Str,




581,549✔





3227



                     keep1Str, keep2Str);










3228



    }










3229



    varDataSetLen(keepVstr, len);




581,549✔





3230



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




581,549✔





3231



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);




581,549✔





3232












3233



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




581,549✔





3234



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);




581,549✔





3235












3236



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




581,549✔





3237



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);




581,549✔





3238












3239



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




581,549✔





3240



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);




581,549✔





3241












3242



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




581,549✔





3243



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);




581,549✔





3244












3245



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




581,549✔





3246



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);




581,549✔





3247












3248



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




581,549✔





3249



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);




581,549✔





3250












3251



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




581,549✔





3252



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);




581,549✔





3253












3254



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




581,549✔





3255



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);




581,549✔





3256












3257



    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);




581,549✔





3258



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




581,549✔





3259



    if (rentensionVstr == NULL) {




581,549✔





3260



      colDataSetNULL(pColInfo, rows);




581,549✔





3261



    } else {










3262



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false), &lino, _OVER);




×







3263



      taosMemoryFree(rentensionVstr);




×







3264



    }










3265












3266



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3267



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);




581,549✔





3268












3269



    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);




581,549✔





3270



    char        cacheModelVstr[24] = {0};




581,549✔





3271



    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);




581,549✔





3272



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3273



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);




581,549✔





3274












3275



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3276



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);




581,549✔





3277












3278



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3279



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastShardBits, false), &lino, _OVER);




581,549✔





3280












3281



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3282



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);




581,549✔





3283












3284



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3285



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);




581,549✔





3286












3287



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3288



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);




581,549✔





3289












3290



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3291



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);




581,549✔





3292












3293



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3294



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);




581,549✔





3295












3296



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3297



    int16_t hashPrefix = pDb->cfg.hashPrefix;




581,549✔





3298



    if (hashPrefix > 0) {




581,549✔





3299



      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;




4,789✔





3300



    } else if (hashPrefix < 0) {




576,760✔





3301



      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;




5,368✔





3302



    }










3303



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);




581,549✔





3304












3305



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3306



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);




581,549✔





3307












3308



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3309



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);




581,549✔





3310












3311



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3312



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);




581,549✔





3313












3314



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3315



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssChunkSize, false), &lino, _OVER);




581,549✔





3316












3317



    char keeplocalVstr[128] = {0};




581,549✔





3318



    len = snprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr) - VARSTR_HEADER_SIZE, "%dm",




581,549✔





3319



                   pDb->cfg.ssKeepLocal);










3320



    varDataSetLen(keeplocalVstr, len);




581,549✔





3321



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3322



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);




581,549✔





3323












3324



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3325



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssCompact, false), &lino, _OVER);




581,549✔





3326












3327



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3328



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);




581,549✔





3329












3330



    char encryptAlgorithmStr[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};




581,549✔





3331



    getEncryptAlgorithmStr(pMnode, pDb->cfg.encryptAlgorithm, encryptAlgorithmStr);




581,549✔





3332



    char        encryptAlgorithmVStr[24] = {0};




581,549✔





3333



    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);




581,549✔





3334



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




581,549✔





3335



    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);




581,549✔





3336












3337



    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));




581,549✔





3338



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




581,549✔





3339



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3340



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




581,549✔





3341



    }










3342












3343



    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);




581,549✔





3344



    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));




581,549✔





3345



    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));




581,549✔





3346



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




581,549✔





3347



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3348



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




581,549✔





3349



    }










3350












3351



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));




581,549✔





3352



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




581,549✔





3353



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3354



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




581,549✔





3355



    }










3356












3357



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3358



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.isAudit, false), &lino, _OVER);




581,549✔





3359



    }










3360












3361



    if (!(*ppUidNames)) {




581,549✔





3362



      TAOS_CHECK_GOTO(mndBuildUidNamesHash(pMnode, ppUidNames), &lino, _OVER);




328,819✔





3363



    }










3364



    const char *ownerName = tSimpleHashGet(*ppUidNames, (const char *)&pDb->ownerId, sizeof(pDb->ownerId));




581,549✔





3365



    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%s", ownerName ? ownerName : "[unknown]"));




581,549✔





3366



    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));




581,549✔





3367



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3368



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);




581,549✔





3369



    }










3370












3371



    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {




581,549✔





3372



      uint8_t allowDrop = pDb->cfg.allowDrop;




581,549✔





3373



      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&allowDrop, false), &lino, _OVER);




581,549✔





3374



    }










3375



  }










3376



_OVER:




1,574,373✔





3377



  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));




1,574,373✔





3378



  taosMemoryFree(buf);




1,574,373✔





3379



}










3380












3381



static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




494,076✔





3382



  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));




494,076✔





3383



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




494,076✔





3384



  pDbObj->cfg.numOfVgroups = 0;




494,076✔





3385



  pDbObj->cfg.strict = 1;




494,076✔





3386



  pDbObj->cfg.replications = 1;




494,076✔





3387



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




494,076✔





3388



}




494,076✔





3389












3390



static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {




494,076✔





3391



  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));




494,076✔





3392



  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);




494,076✔





3393



  pDbObj->cfg.numOfVgroups = 0;




494,076✔





3394



  pDbObj->cfg.strict = 1;




494,076✔





3395



  pDbObj->cfg.replications = 1;




494,076✔





3396



  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;




494,076✔





3397



}




494,076✔





3398












3399



static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {




4,787,294✔





3400



  SVgObj  *pVgroup = pObj;




4,787,294✔





3401



  int32_t *numOfTables = p1;




4,787,294✔





3402



  int64_t  uid = *(int64_t *)p2;




4,787,294✔





3403



  if (pVgroup->dbUid == uid) {




4,787,294✔





3404



    *numOfTables += pVgroup->numOfTables;




1,544,466✔





3405



  }










3406



  return true;




4,787,294✔





3407



}










3408












3409



static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {




494,076✔





3410



  SMnode    *pMnode = pReq->info.node;




494,076✔





3411



  SSdb      *pSdb = pMnode->pSdb;




494,076✔





3412



  int32_t    numOfRows = 0;




494,076✔





3413



  SDbObj    *pDb = NULL;




494,076✔





3414



  SUserObj  *pOperUser = NULL;




494,076✔





3415



  ESdbStatus objStatus = 0;




494,076✔





3416



  SSHashObj *pUidNames = NULL;




494,076✔





3417












3418



  (void)mndAcquireUser(pMnode, RPC_MSG_USER(pReq), &pOperUser);




494,076✔





3419



  if (pOperUser == NULL) return 0;




494,076✔





3420



  bool sysinfo = pOperUser->sysInfo;




494,076✔





3421



  char objFName[TSDB_OBJ_FNAME_LEN + 1] = {0};




494,076✔





3422



  (void)snprintf(objFName, sizeof(objFName), "%d.*", pOperUser->acctId);




494,076✔





3423



  bool showAnyDb = (0 == mndCheckSysObjPrivilege(pMnode, pOperUser, RPC_MSG_TOKEN(pReq), PRIV_CM_SHOW, PRIV_OBJ_DB, 0,




494,076✔





3424



                                                 objFName, NULL));










3425












3426



  // Append the information_schema database into the result.










3427



  if (!pShow->sysDbRsp) {




494,076✔





3428



    SDbObj infoschemaDb = {0};




494,076✔





3429



    setInformationSchemaDbCfg(pMnode, &infoschemaDb);




494,076✔





3430



    size_t numOfTables = 0;




494,076✔





3431



    getVisibleInfosTablesNum(sysinfo, &numOfTables);




494,076✔





3432



    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




494,076✔





3433












3434



    numOfRows += 1;




494,076✔





3435












3436



    SDbObj perfschemaDb = {0};




494,076✔





3437



    setPerfSchemaDbCfg(pMnode, &perfschemaDb);




494,076✔





3438



    numOfTables = 0;




494,076✔





3439



    getPerfDbMeta(NULL, &numOfTables);




494,076✔





3440



    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1, &pUidNames);




494,076✔





3441












3442



    numOfRows += 1;




494,076✔





3443



    pShow->sysDbRsp = true;




494,076✔





3444



  }










3445












3446



  while (numOfRows < rowsCapacity) {




1,080,297✔





3447



    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);




1,080,297✔





3448



    if (pShow->pIter == NULL) break;




1,080,297✔





3449



    if (showAnyDb || mndCheckDbPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_SHOW_DATABASES, pDb) == 0) {




586,221✔





3450



      int32_t numOfTables = 0;




586,221✔





3451



      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);




586,221✔





3452



      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo, &pUidNames);




586,221✔





3453



      numOfRows++;




586,221✔





3454



    }










3455












3456



    sdbRelease(pSdb, pDb);




586,221✔





3457



  }










3458












3459



  pShow->numOfRows += numOfRows;




494,076✔





3460



  mndReleaseUser(pMnode, pOperUser);




494,076✔





3461



  tSimpleHashCleanup(pUidNames);




494,076✔





3462



  return numOfRows;




494,076✔





3463



}










3464












3465



static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {




×







3466



  SSdb *pSdb = pMnode->pSdb;




×







3467



  sdbCancelFetchByType(pSdb, pIter, SDB_DB);




×







3468



}




×





















    

  • 

    •