taosdata / TDengine / #4244

coverage: 62.872% (-0.1%) from 62.995%
#4244

push

travis-ci

web-flow 
add server port and mqttport in configuration file (#31277)

157271 of 319194 branches covered (49.27%)

Branch coverage included in aggregate %.

243262 of 317868 relevant lines covered (76.53%)

6692004.29 hits per line

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

87.03
/source/dnode/mnode/sdb/src/sdbHash.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 "sdb.h"










18












19



static void sdbCheckRow(SSdb *pSdb, SSdbRow *pRow);










20












21



const char *sdbTableName(ESdbType type) {




2,766,372✔





22



  switch (type) {





2,766,372!





23



    case SDB_TRANS:




249,568✔





24



      return "trans";




249,568✔





25



    case SDB_CLUSTER:




30,901✔





26



      return "cluster";




30,901✔





27



    case SDB_MNODE:




33,153✔





28



      return "mnode";




33,153✔





29



    case SDB_QNODE:




28,477✔





30



      return "qnode";




28,477✔





31



    case SDB_SNODE:




9,335✔





32



      return "snode";




9,335✔





33



    case SDB_DNODE:




314,514✔





34



      return "dnode";




314,514✔





35



    case SDB_USER:




235,052✔





36



      return "user";




235,052✔





37



    case SDB_AUTH:




6✔





38



      return "auth";




6✔





39



    case SDB_ACCT:




17,580✔





40



      return "acct";




17,580✔





41



    case SDB_STREAM_CK:




6✔





42



      return "stream_ck";




6✔





43



    case SDB_STREAM:




25,396✔





44



      return "stream";




25,396✔





45



    case SDB_OFFSET:




6✔





46



      return "offset";




6✔





47



    case SDB_SUBSCRIBE:




13,317✔





48



      return "subscribe";




13,317✔





49



    case SDB_CONSUMER:




17,393✔





50



      return "consumer";




17,393✔





51



    case SDB_TOPIC:




11,937✔





52



      return "topic";




11,937✔





53



    case SDB_VGROUP:




653,150✔





54



      return "vgroup";




653,150✔





55



    case SDB_SMA:




17,357✔





56



      return "sma";




17,357✔





57



    case SDB_STB:




121,015✔





58



      return "stb";




121,015✔





59



    case SDB_DB:




222,574✔





60



      return "db";




222,574✔





61



    case SDB_FUNC:




12,221✔





62



      return "func";




12,221✔





63



    case SDB_IDX:




45,568✔





64



      return "idx";




45,568✔





65



    case SDB_VIEW:




12,142✔





66



      return "view";




12,142✔





67



    case SDB_STREAM_SEQ:




9,174✔





68



      return "stream_seq";




9,174✔





69



    case SDB_COMPACT:




9,243✔





70



      return "compact";




9,243✔





71



    case SDB_COMPACT_DETAIL:




9,465✔





72



      return "compact_detail";




9,465✔





73



    case SDB_GRANT:




21,270✔





74



      return "grant";




21,270✔





75



    case SDB_ARBGROUP:




9,275✔





76



      return "arb_group";




9,275✔





77



    case SDB_ANODE:




9,187✔





78



      return "anode";




9,187✔





79



    case SDB_CFG:




628,104✔





80



      return "config";




628,104✔





81



    default:




×







82



      return "undefine";




×







83



  }










84



}










85












86



const char *sdbStatusName(ESdbStatus status) {




1,944,259✔





87



  switch (status) {





1,944,259!





88



    case SDB_STATUS_CREATING:




32,244✔





89



      return "creating";




32,244✔





90



    case SDB_STATUS_DROPPING:




6,746✔





91



      return "dropping";




6,746✔





92



    case SDB_STATUS_READY:




1,839,352✔





93



      return "ready";




1,839,352✔





94



    case SDB_STATUS_DROPPED:




58,053✔





95



      return "dropped";




58,053✔





96



    case SDB_STATUS_INIT:




7,864✔





97



      return "init";




7,864✔





98



    case SDB_STATUS_UPDATE:




×







99



      return "update";




×







100



    default:




×







101



      return "undefine";




×







102



  }










103



}










104












105



void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) {




10,438,286✔





106



#if 1










107



  EKeyType keyType = pSdb->keyTypes[pRow->type];




10,438,286✔





108












109



  if (keyType == SDB_KEY_BINARY) {





10,438,286✔





110



    mTrace("%s:%s, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj,





3,483,629✔





111



           pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));










112



  } else if (keyType == SDB_KEY_INT32) {





6,954,657✔





113



    mTrace("%s:%d, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj,





6,680,677✔





114



           pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));










115



  } else if (keyType == SDB_KEY_INT64) {





273,980!





116



    mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),





274,467✔





117



           *(int64_t *)pRow->pObj, pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));










118



  } else {










119



  }










120



#endif










121



}




10,438,292✔





122












123



static SHashObj *sdbGetHash(SSdb *pSdb, int32_t type) {




6,953,640✔





124



  if (type >= SDB_MAX || type < 0) {





6,953,640!





125



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




×







126



    return NULL;




1✔





127



  }










128












129



  SHashObj *hash = pSdb->hashObjs[type];




6,953,689✔





130



  if (hash == NULL) {





6,953,689✔





131



    terrno = TSDB_CODE_APP_ERROR;




4✔





132



    return NULL;




4✔





133



  }










134












135



  return hash;




6,953,685✔





136



}










137












138



static int32_t sdbGetkeySize(SSdb *pSdb, ESdbType type, const void *pKey) {




2,937,389✔





139



  int32_t  keySize = 0;




2,937,389✔





140



  EKeyType keyType = pSdb->keyTypes[type];




2,937,389✔





141












142



  if (keyType == SDB_KEY_INT32) {





2,937,389✔





143



    keySize = sizeof(int32_t);




1,792,046✔





144



  } else if (keyType == SDB_KEY_BINARY) {





1,145,343✔





145



    keySize = strlen(pKey) + 1;




1,121,450✔





146



  } else {










147



    keySize = sizeof(int64_t);




23,893✔





148



  }










149












150



  return keySize;




2,937,389✔





151



}










152












153



static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) {




324,009✔





154



  int32_t type = pRow->type;




324,009✔





155



  sdbWriteLock(pSdb, type);




324,009✔





156












157



  SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);




324,009✔





158



  if (pOldRow != NULL) {





324,009!





159



    sdbUnLock(pSdb, type);




×







160



    sdbFreeRow(pSdb, pRow, false);




×







161



    terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;




×







162



    return terrno;




×







163



  }










164












165



  pRow->refCount = 0;




324,009✔





166



  pRow->status = pRaw->status;




324,009✔





167



  sdbPrintOper(pSdb, pRow, "insert");




324,009✔





168












169



  int32_t code = 0;




324,009✔





170



  if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {





324,009!





171



    sdbUnLock(pSdb, type);




×







172



    sdbFreeRow(pSdb, pRow, false);




×







173



    return code;




×







174



  }










175












176



  SdbInsertFp insertFp = pSdb->insertFps[pRow->type];




324,009✔





177



  if (insertFp != NULL) {





324,009!





178



    code = (*insertFp)(pSdb, pRow->pObj);




324,009✔





179



    if (code != 0) {





324,009!





180



      if (taosHashRemove(hash, pRow->pObj, keySize) != 0) {





×







181



        mError("failed to remove row from hash");





×







182



      }










183



      sdbFreeRow(pSdb, pRow, false);




×







184



      sdbUnLock(pSdb, type);




×







185



      terrno = code;




×







186



      return terrno;




×







187



    }










188



  }










189












190



  sdbUnLock(pSdb, type);




324,009✔





191












192



  if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {





324,009✔





193



    pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], *((int32_t *)pRow->pObj));




76,942✔





194



  }










195



  if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {





324,009✔





196



    pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], *((int64_t *)pRow->pObj));




2,901✔





197



  }










198



  pSdb->tableVer[pRow->type]++;




324,009✔





199












200



  return 0;




324,009✔





201



}










202












203



static int32_t sdbUpdateRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pNewRow, int32_t keySize) {




424,930✔





204



  int32_t type = pNewRow->type;




424,930✔





205



  sdbWriteLock(pSdb, type);




424,930✔





206












207



  SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);




424,930✔





208



  if (ppOldRow == NULL || *ppOldRow == NULL) {





424,930!





209



    sdbUnLock(pSdb, type);




307,682✔





210



    return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);




307,682✔





211



  }










212












213



  SSdbRow *pOldRow = *ppOldRow;




117,248✔





214



  pOldRow->status = pRaw->status;




117,248✔





215



  sdbPrintOper(pSdb, pOldRow, "update");




117,248✔





216












217



  int32_t     code = 0;




117,248✔





218



  SdbUpdateFp updateFp = pSdb->updateFps[type];




117,248✔





219



  if (updateFp != NULL) {





117,248!





220



    code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);




117,248✔





221



  }










222



  sdbUnLock(pSdb, type);




117,248✔





223












224



  // sdbUnLock(pSdb, type);










225



  sdbFreeRow(pSdb, pNewRow, false);




117,248✔





226












227



  pSdb->tableVer[pOldRow->type]++;




117,248✔





228



  return code;




117,248✔





229



}










230












231



static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) {




72,418✔





232



  int32_t type = pRow->type;




72,418✔





233



  sdbWriteLock(pSdb, type);




72,418✔





234












235



  SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);




72,418✔





236



  if (ppOldRow == NULL || *ppOldRow == NULL) {





72,418!





237



    sdbUnLock(pSdb, type);




38✔





238



    sdbFreeRow(pSdb, pRow, false);




38✔





239



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




38✔





240



    return terrno;




38✔





241



  }










242



  SSdbRow *pOldRow = *ppOldRow;




72,380✔





243



  pOldRow->status = pRaw->status;




72,380✔





244












245



  (void)atomic_add_fetch_32(&pOldRow->refCount, 1);




72,380✔





246



  sdbPrintOper(pSdb, pOldRow, "delete");




72,380✔





247












248



  if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {





72,380!





249



    sdbUnLock(pSdb, type);




×







250



    sdbFreeRow(pSdb, pRow, false);




×







251



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




×







252



    return terrno;




×







253



  }










254



  pSdb->tableVer[pOldRow->type]++;




72,380✔





255



  sdbUnLock(pSdb, type);




72,380✔





256












257



  sdbFreeRow(pSdb, pRow, false);




72,380✔





258












259



  sdbCheckRow(pSdb, pOldRow);




72,380✔





260



  return 0;




72,380✔





261



}










262












263



int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw) {




513,677✔





264



  if (pRaw->type == SDB_CFG) {





513,677✔





265



    mTrace("sdb write cfg");





209,690✔





266



  }










267



  SHashObj *hash = sdbGetHash(pSdb, pRaw->type);




513,677✔





268



  if (hash == NULL) return terrno;





513,677✔





269












270



  SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];




513,675✔





271



  SSdbRow    *pRow = (*decodeFp)(pRaw);




513,675✔





272



  if (pRow == NULL) return terrno;





513,675!





273












274



  pRow->type = pRaw->type;




513,675✔





275












276



  int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);




513,675✔





277



  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;




513,675✔





278












279



  switch (pRaw->status) {





513,675!





280



    case SDB_STATUS_CREATING:




16,327✔





281



      code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);




16,327✔





282



      break;




16,327✔





283



    case SDB_STATUS_READY:




424,930✔





284



    case SDB_STATUS_UPDATE:










285



    case SDB_STATUS_DROPPING:










286



      code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);




424,930✔





287



      break;




424,930✔





288



    case SDB_STATUS_DROPPED:




72,418✔





289



      code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);




72,418✔





290



      break;




72,418✔





291



  }










292












293



  return code;




513,675✔





294



}










295












296



int32_t sdbWrite(SSdb *pSdb, SSdbRaw *pRaw) {




57,517✔





297



  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);




57,517✔





298



  sdbFreeRaw(pRaw);




57,517✔





299



  return code;




57,517✔





300



}










301












302



void *sdbAcquireAll(SSdb *pSdb, ESdbType type, const void *pKey, bool onlyReady) {




2,423,730✔





303



  terrno = 0;




2,423,730✔





304












305



  SHashObj *hash = sdbGetHash(pSdb, type);




2,423,726✔





306



  if (hash == NULL) return NULL;





2,423,717✔





307












308



  void   *pRet = NULL;




2,423,716✔





309



  int32_t keySize = sdbGetkeySize(pSdb, type, pKey);




2,423,716✔





310












311



  sdbReadLock(pSdb, type);




2,423,717✔





312












313



  SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);




2,423,733✔





314



  if (ppRow == NULL || *ppRow == NULL) {





2,423,737✔





315



    sdbUnLock(pSdb, type);




372,666✔





316



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




372,666✔





317



    return NULL;




372,666✔





318



  }










319












320



  SSdbRow *pRow = *ppRow;




2,051,071✔





321



  switch (pRow->status) {





2,051,071✔





322



    case SDB_STATUS_READY:




2,043,923✔





323



      (void)atomic_add_fetch_32(&pRow->refCount, 1);




2,043,923✔





324



      pRet = pRow->pObj;




2,043,945✔





325



      sdbPrintOper(pSdb, pRow, "acquire");




2,043,945✔





326



      break;




2,043,943✔





327



    case SDB_STATUS_CREATING:




5,243✔





328



      terrno = TSDB_CODE_SDB_OBJ_CREATING;




5,243✔





329



      break;




5,243✔





330



    case SDB_STATUS_DROPPING:




1,903✔





331



      terrno = TSDB_CODE_SDB_OBJ_DROPPING;




1,903✔





332



      break;




1,903✔





333



    default:




2✔





334



      terrno = TSDB_CODE_APP_ERROR;




2✔





335



      break;




×







336



  }










337












338



  if (pRet == NULL) {





2,051,089✔





339



    if (!onlyReady) {





7,146!





340



      terrno = 0;




×







341



      (void)atomic_add_fetch_32(&pRow->refCount, 1);




×







342



      pRet = pRow->pObj;




×







343



      sdbPrintOper(pSdb, pRow, "acquire");




×







344



    }










345



  }










346












347



  sdbUnLock(pSdb, type);




2,051,089✔





348



  return pRet;




2,051,093✔





349



}










350












351



void *sdbAcquire(SSdb *pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }




2,420,816✔





352



void *sdbAcquireNotReadyObj(SSdb *pSdb, ESdbType type, const void *pKey) {




2,912✔





353



  return sdbAcquireAll(pSdb, type, pKey, false);




2,912✔





354



}










355












356



static void sdbCheckRow(SSdb *pSdb, SSdbRow *pRow) {




72,380✔





357



  int32_t type = pRow->type;




72,380✔





358



  sdbWriteLock(pSdb, type);




72,380✔





359












360



  int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);




72,380✔





361



  sdbPrintOper(pSdb, pRow, "check");




72,380✔





362



  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {





72,380!





363



    sdbFreeRow(pSdb, pRow, true);




13,742✔





364



  }










365












366



  sdbUnLock(pSdb, type);




72,380✔





367



}




72,380✔





368












369



void sdbReleaseLock(SSdb *pSdb, void *pObj, bool lock) {




4,518,282✔





370



  if (pObj == NULL) return;





4,518,282✔





371












372



  SSdbRow *pRow = (SSdbRow *)((char *)pObj - sizeof(SSdbRow));




4,446,939✔





373



  if (pRow->type >= SDB_MAX) return;





4,446,939!





374












375



  int32_t type = pRow->type;




4,446,939✔





376



  if (lock) {





4,446,939✔





377



    sdbWriteLock(pSdb, type);




4,442,500✔





378



  }










379












380



  int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);




4,447,168✔





381



  sdbPrintOper(pSdb, pRow, "release");




4,447,228✔





382



  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {





4,447,221✔





383



    sdbFreeRow(pSdb, pRow, true);




58,638✔





384



  }










385



  if (ref < 0) {





4,447,221✔





386



    mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));





2,856!





387



  }










388












389



  if (lock) {





4,447,224✔





390



    sdbUnLock(pSdb, type);




4,442,754✔





391



  }










392



}










393












394



void sdbRelease(SSdb *pSdb, void *pObj) { sdbReleaseLock(pSdb, pObj, true); }




4,513,823✔





395












396



void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {




2,712,205✔





397



  *ppObj = NULL;




2,712,205✔





398












399



  SHashObj *hash = sdbGetHash(pSdb, type);




2,712,205✔





400



  if (hash == NULL) return NULL;





2,712,147✔





401












402



  sdbReadLock(pSdb, type);




2,712,146✔





403












404



  SSdbRow **ppRow = taosHashIterate(hash, pIter);




2,712,280✔





405



  while (ppRow != NULL) {





2,727,194✔





406



    SSdbRow *pRow = *ppRow;




2,138,575✔





407



    if (pRow == NULL || pRow->status != SDB_STATUS_READY) {





2,138,575!





408



      ppRow = taosHashIterate(hash, ppRow);




14,815✔





409



      continue;




14,813✔





410



    }










411












412



    (void) atomic_add_fetch_32(&pRow->refCount, 1);




2,123,760✔





413












414



    sdbPrintOper(pSdb, pRow, "fetch");




2,123,768✔





415



    *ppObj = pRow->pObj;




2,123,746✔





416



    break;




2,123,746✔





417



  }










418



  sdbUnLock(pSdb, type);




2,712,365✔





419












420



  return ppRow;




2,712,403✔





421



}










422












423



void *sdbFetchAll(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj, ESdbStatus *status, bool lock) {




353,118✔





424



  *ppObj = NULL;




353,118✔





425












426



  SHashObj *hash = sdbGetHash(pSdb, type);




353,118✔





427



  if (hash == NULL) return NULL;





353,118!





428












429



  if (lock) {





353,118✔





430



    sdbReadLock(pSdb, type);




345,362✔





431



  }










432












433



  SSdbRow **ppRow = taosHashIterate(hash, pIter);




353,118✔





434



  while (ppRow != NULL) {





353,118✔





435



    SSdbRow *pRow = *ppRow;




279,607✔





436



    if (pRow == NULL) {





279,607!





437



      ppRow = taosHashIterate(hash, ppRow);




×







438



      continue;




×







439



    }










440












441



    (void)atomic_add_fetch_32(&pRow->refCount, 1);




279,607✔





442



    sdbPrintOper(pSdb, pRow, "fetch");




279,607✔





443



    *ppObj = pRow->pObj;




279,607✔





444



    *status = pRow->status;




279,607✔





445



    break;




279,607✔





446



  }










447



  if (lock) {





353,118✔





448



    sdbUnLock(pSdb, type);




345,362✔





449



  }










450












451



  return ppRow;




353,118✔





452



}










453












454



void sdbCancelFetch(SSdb *pSdb, void *pIter) {




411,834✔





455



  if (pIter == NULL) return;





411,834✔





456



  SSdbRow *pRow = *(SSdbRow **)pIter;




409,798✔





457



  mTrace("cancel fetch row:%p", pRow);





409,798✔





458



  SHashObj *hash = sdbGetHash(pSdb, pRow->type);




409,798✔





459



  if (hash == NULL) return;





409,798!





460












461



  int32_t type = pRow->type;




409,798✔





462



  sdbReadLock(pSdb, type);




409,798✔





463



  taosHashCancelIterate(hash, pIter);




409,798✔





464



  sdbUnLock(pSdb, type);




409,798✔





465



}










466












467



void sdbCancelFetchByType(SSdb *pSdb, void *pIter, ESdbType type) {




1✔





468



  if (pIter == NULL) return;





1!





469



  if (type >= SDB_MAX || type < 0) return;





1!





470



  SHashObj *hash = sdbGetHash(pSdb, type);




1✔





471



  if (hash == NULL) return;





1!





472












473



  sdbReadLock(pSdb, type);




1✔





474



  taosHashCancelIterate(hash, pIter);




1✔





475



  sdbUnLock(pSdb, type);




1✔





476



}










477












478



void sdbTraverse(SSdb *pSdb, ESdbType type, sdbTraverseFp fp, void *p1, void *p2, void *p3) {




29,017✔





479



  SHashObj *hash = sdbGetHash(pSdb, type);




29,017✔





480



  if (hash == NULL) return;





29,017!





481












482



  sdbReadLock(pSdb, type);




29,017✔





483












484



  SSdbRow **ppRow = taosHashIterate(hash, NULL);




29,017✔





485



  while (ppRow != NULL) {





100,417✔





486



    SSdbRow *pRow = *ppRow;




71,402✔





487



    if (pRow->status == SDB_STATUS_READY) {





71,402✔





488



      bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);




61,310✔





489



      if (!isContinue) {





61,310✔





490



        taosHashCancelIterate(hash, ppRow);




2✔





491



        break;




2✔





492



      }










493



    }










494












495



    ppRow = taosHashIterate(hash, ppRow);




71,400✔





496



  }










497












498



  sdbUnLock(pSdb, type);




29,017✔





499



}










500












501



int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {




448,807✔





502



  SHashObj *hash = sdbGetHash(pSdb, type);




448,807✔





503



  if (hash == NULL) return 0;





448,807!





504












505



  sdbReadLock(pSdb, type);




448,807✔





506



  int32_t size = taosHashGetSize(hash);




448,806✔





507



  sdbUnLock(pSdb, type);




448,806✔





508












509



  return size;




448,807✔





510



}










511












512



int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {




64,059✔





513



  SHashObj *hash = sdbGetHash(pSdb, type);




64,059✔





514



  if (hash == NULL) return -1;





64,059✔





515












516



  if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;





64,058✔





517












518



  int32_t maxId = 0;




64,052✔





519



  sdbReadLock(pSdb, type);




64,052✔





520












521



  SSdbRow **ppRow = taosHashIterate(hash, NULL);




64,052✔





522



  while (ppRow != NULL) {





110,363✔





523



    SSdbRow *pRow = *ppRow;




46,311✔





524



    int32_t  id = *(int32_t *)pRow->pObj;




46,311✔





525



    maxId = TMAX(id, maxId);




46,311✔





526



    ppRow = taosHashIterate(hash, ppRow);




46,311✔





527



  }










528












529



  sdbUnLock(pSdb, type);




64,052✔





530



  maxId = TMAX(maxId, pSdb->maxId[type]);




64,052✔





531



  return maxId + 1;




64,052✔





532



}










533












534



int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {




293,588✔





535



  if (type >= SDB_MAX || type < 0) {





293,588✔





536



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




1✔





537



    return -1;




1✔





538



  }










539












540



  return pSdb->tableVer[type];




293,587✔





541



}










542












543



bool countValid(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {




×







544



  int32_t *pInt = p1;




×







545



  (*pInt) += 1;




×







546



  return true;




×







547



}










548












549



int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {




×







550



  int32_t num = 0;




×







551



  sdbTraverse(pSdb, type, countValid, &num, 0, 0);




×







552



  return num;




×







553



}
























    

  • 

    •