taosdata / TDengine / #4364

coverage: 62.393% (+0.3%) from 62.074%
#4364

push

travis-ci

web-flow 
docs: add OpenMetrics support and configuration details to taosAdapter documentation (#31427)

* docs: add OpenMetrics support and configuration details to taosAdapter documentation

* docs: enhance OpenMetrics section in taosAdapter documentation

156300 of 319947 branches covered (48.85%)

Branch coverage included in aggregate %.

242300 of 318911 relevant lines covered (75.98%)

18133151.98 hits per line

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

87.75
/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,601,361✔





22



  switch (type) {





2,601,361!





23



    case SDB_TRANS:




232,425✔





24



      return "trans";




232,425✔





25



    case SDB_CLUSTER:




26,859✔





26



      return "cluster";




26,859✔





27



    case SDB_MNODE:




28,786✔





28



      return "mnode";




28,786✔





29



    case SDB_QNODE:




26,023✔





30



      return "qnode";




26,023✔





31



    case SDB_SNODE:




8,978✔





32



      return "snode";




8,978✔





33



    case SDB_DNODE:




302,429✔





34



      return "dnode";




302,429✔





35



    case SDB_USER:




224,984✔





36



      return "user";




224,984✔





37



    case SDB_AUTH:




2✔





38



      return "auth";




2✔





39



    case SDB_ACCT:




16,307✔





40



      return "acct";




16,307✔





41



    case SDB_STREAM_CK:




2✔





42



      return "stream_ck";




2✔





43



    case SDB_STREAM:




27,801✔





44



      return "stream";




27,801✔





45



    case SDB_OFFSET:




2✔





46



      return "offset";




2✔





47



    case SDB_SUBSCRIBE:




12,592✔





48



      return "subscribe";




12,592✔





49



    case SDB_CONSUMER:




16,314✔





50



      return "consumer";




16,314✔





51



    case SDB_TOPIC:




11,356✔





52



      return "topic";




11,356✔





53



    case SDB_VGROUP:




619,459✔





54



      return "vgroup";




619,459✔





55



    case SDB_SMA:




16,999✔





56



      return "sma";




16,999✔





57



    case SDB_STB:




111,598✔





58



      return "stb";




111,598✔





59



    case SDB_DB:




214,595✔





60



      return "db";




214,595✔





61



    case SDB_FUNC:




8,921✔





62



      return "func";




8,921✔





63



    case SDB_IDX:




55,112✔





64



      return "idx";




55,112✔





65



    case SDB_VIEW:




10,294✔





66



      return "view";




10,294✔





67



    case SDB_STREAM_SEQ:




8,718✔





68



      return "stream_seq";




8,718✔





69



    case SDB_COMPACT:




8,748✔





70



      return "compact";




8,748✔





71



    case SDB_COMPACT_DETAIL:




8,898✔





72



      return "compact_detail";




8,898✔





73



    case SDB_GRANT:




19,815✔





74



      return "grant";




19,815✔





75



    case SDB_ARBGROUP:




8,819✔





76



      return "arb_group";




8,819✔





77



    case SDB_ANODE:




8,731✔





78



      return "anode";




8,731✔





79



    case SDB_CFG:




565,831✔





80



      return "config";




565,831✔





81



    default:




×







82



      return "undefine";




×







83



  }










84



}










85












86



const char *sdbStatusName(ESdbStatus status) {




1,827,981✔





87



  switch (status) {





1,827,981!





88



    case SDB_STATUS_CREATING:




31,386✔





89



      return "creating";




31,386✔





90



    case SDB_STATUS_DROPPING:




8,270✔





91



      return "dropping";




8,270✔





92



    case SDB_STATUS_READY:




1,726,790✔





93



      return "ready";




1,726,790✔





94



    case SDB_STATUS_DROPPED:




55,708✔





95



      return "dropped";




55,708✔





96



    case SDB_STATUS_INIT:




5,826✔





97



      return "init";




5,826✔





98



    case SDB_STATUS_UPDATE:




×







99



      return "update";




×







100



    default:




1✔





101



      return "undefine";




1✔





102



  }










103



}










104












105



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




505,686,669✔





106



#if 1










107



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




505,686,669✔





108












109



  if (keyType == SDB_KEY_BINARY) {





505,686,669✔





110



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





55,223,908✔





111



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










112



  } else if (keyType == SDB_KEY_INT32) {





450,462,761✔





113



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





450,123,921✔





114



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










115



  } else if (keyType == SDB_KEY_INT64) {





338,840!





116



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





434,053✔





117



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










118



  } else {










119



  }










120



#endif










121



}




505,686,682✔





122












123



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




264,432,105✔





124



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





264,432,105!





125



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




×







126



    return NULL;




1✔





127



  }










128












129



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




264,434,929✔





130



  if (hash == NULL) {





264,434,929✔





131



    terrno = TSDB_CODE_APP_ERROR;




4✔





132



    return NULL;




4✔





133



  }










134












135



  return hash;




264,434,925✔





136



}










137












138



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




39,423,184✔





139



  int32_t  keySize = 0;




39,423,184✔





140



  EKeyType keyType = pSdb->keyTypes[type];




39,423,184✔





141












142



  if (keyType == SDB_KEY_INT32) {





39,423,184✔





143



    keySize = sizeof(int32_t);




24,596,399✔





144



  } else if (keyType == SDB_KEY_BINARY) {





14,826,785✔





145



    keySize = strlen(pKey) + 1;




14,809,966✔





146



  } else {










147



    keySize = sizeof(int64_t);




16,819✔





148



  }










149












150



  return keySize;




39,423,184✔





151



}










152












153



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




310,042✔





154



  int32_t type = pRow->type;




310,042✔





155



  sdbWriteLock(pSdb, type);




310,042✔





156












157



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




310,042✔





158



  if (pOldRow != NULL) {





310,042!





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;




310,042✔





166



  pRow->status = pRaw->status;




310,042✔





167



  sdbPrintOper(pSdb, pRow, "insert");




310,042✔





168












169



  int32_t code = 0;




310,042✔





170



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





310,042!





171



    sdbUnLock(pSdb, type);




×







172



    sdbFreeRow(pSdb, pRow, false);




×







173



    return code;




×







174



  }










175












176



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




310,042✔





177



  if (insertFp != NULL) {





310,042!





178



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




310,042✔





179



    if (code != 0) {





310,042!





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




310,042✔





191












192



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





310,042✔





193



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




74,614✔





194



  }










195



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





310,042✔





196



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




2,716✔





197



  }










198



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




310,042✔





199












200



  return 0;




310,042✔





201



}










202












203



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




410,974✔





204



  int32_t type = pNewRow->type;




410,974✔





205



  sdbWriteLock(pSdb, type);




410,974✔





206












207



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




410,974✔





208



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





410,974!





209



    sdbUnLock(pSdb, type);




294,065✔





210



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




294,065✔





211



  }










212












213



  SSdbRow *pOldRow = *ppOldRow;




116,909✔





214



  pOldRow->status = pRaw->status;




116,909✔





215



  sdbPrintOper(pSdb, pOldRow, "update");




116,909✔





216












217



  int32_t     code = 0;




116,909✔





218



  SdbUpdateFp updateFp = pSdb->updateFps[type];




116,909✔





219



  if (updateFp != NULL) {





116,909!





220



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




116,909✔





221



  }










222



  sdbUnLock(pSdb, type);




116,909✔





223












224



  // sdbUnLock(pSdb, type);










225



  sdbFreeRow(pSdb, pNewRow, false);




116,909✔





226












227



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




116,909✔





228



  return code;




116,909✔





229



}










230












231



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




72,162✔





232



  int32_t type = pRow->type;




72,162✔





233



  sdbWriteLock(pSdb, type);




72,162✔





234












235



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




72,162✔





236



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





72,162!





237



    sdbUnLock(pSdb, type);




21✔





238



    sdbFreeRow(pSdb, pRow, false);




21✔





239



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




21✔





240



    return terrno;




21✔





241



  }










242



  SSdbRow *pOldRow = *ppOldRow;




72,141✔





243



  pOldRow->status = pRaw->status;




72,141✔





244












245



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




72,141✔





246



  sdbPrintOper(pSdb, pOldRow, "delete");




72,141✔





247












248



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





72,141!





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





255



  sdbUnLock(pSdb, type);




72,141✔





256












257



  sdbFreeRow(pSdb, pRow, false);




72,141✔





258












259



  sdbCheckRow(pSdb, pOldRow);




72,141✔





260



  return 0;




72,141✔





261



}










262












263



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




499,115✔





264



  if (pRaw->type == SDB_CFG) {





499,115✔





265



    mTrace("sdb write cfg");





200,058✔





266



  }










267



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




499,115✔





268



  if (hash == NULL) return terrno;





499,115✔





269












270



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




499,113✔





271



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




499,113✔





272



  if (pRow == NULL) return terrno;





499,113!





273












274



  pRow->type = pRaw->type;




499,113✔





275












276



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




499,113✔





277



  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;




499,113✔





278












279



  switch (pRaw->status) {





499,113!





280



    case SDB_STATUS_CREATING:




15,977✔





281



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




15,977✔





282



      break;




15,977✔





283



    case SDB_STATUS_READY:




410,974✔





284



    case SDB_STATUS_UPDATE:










285



    case SDB_STATUS_DROPPING:










286



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




410,974✔





287



      break;




410,974✔





288



    case SDB_STATUS_DROPPED:




72,162✔





289



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




72,162✔





290



      break;




72,162✔





291



  }










292












293



  return code;




499,113✔





294



}










295












296



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




55,878✔





297



  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);




55,878✔





298



  sdbFreeRaw(pRaw);




55,878✔





299



  return code;




55,878✔





300



}










301












302



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




38,923,153✔





303



  terrno = 0;




38,923,153✔





304












305



  SHashObj *hash = sdbGetHash(pSdb, type);




38,922,697✔





306



  if (hash == NULL) return NULL;





38,921,946✔





307












308



  void   *pRet = NULL;




38,921,945✔





309



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




38,921,945✔





310












311



  sdbReadLock(pSdb, type);




38,924,724✔





312












313



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




38,933,382✔





314



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





38,932,798✔





315



    sdbUnLock(pSdb, type);




1,897,652✔





316



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




1,898,020✔





317



    return NULL;




1,898,013✔





318



  }










319












320



  SSdbRow *pRow = *ppRow;




37,035,146✔





321



  switch (pRow->status) {





37,035,146!





322



    case SDB_STATUS_READY:




37,027,613✔





323



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




37,027,613✔





324



      pRet = pRow->pObj;




37,029,391✔





325



      sdbPrintOper(pSdb, pRow, "acquire");




37,029,391✔





326



      break;




37,026,431✔





327



    case SDB_STATUS_CREATING:




5,554✔





328



      terrno = TSDB_CODE_SDB_OBJ_CREATING;




5,554✔





329



      break;




5,554✔





330



    case SDB_STATUS_DROPPING:




2,062✔





331



      terrno = TSDB_CODE_SDB_OBJ_DROPPING;




2,062✔





332



      break;




2,062✔





333



    default:




×







334



      terrno = TSDB_CODE_APP_ERROR;




×







335



      break;




×







336



  }










337












338



  if (pRet == NULL) {





37,034,047✔





339



    if (!onlyReady) {





7,616✔





340



      terrno = 0;




1✔





341



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




1✔





342



      pRet = pRow->pObj;




1✔





343



      sdbPrintOper(pSdb, pRow, "acquire");




1✔





344



    }










345



  }










346












347



  sdbUnLock(pSdb, type);




37,034,047✔





348



  return pRet;




37,034,686✔





349



}










350












351



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




38,916,898✔





352



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




2,772✔





353



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




2,772✔





354



}










355












356



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




72,141✔





357



  int32_t type = pRow->type;




72,141✔





358



  sdbWriteLock(pSdb, type);




72,141✔





359












360



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




72,141✔





361



  sdbPrintOper(pSdb, pRow, "check");




72,141✔





362



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





72,141!





363



    sdbFreeRow(pSdb, pRow, true);




15,503✔





364



  }










365












366



  sdbUnLock(pSdb, type);




72,141✔





367



}




72,141✔





368












369



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




252,434,338✔





370



  if (pObj == NULL) return;





252,434,338✔





371












372



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




251,982,737✔





373



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





251,982,737!





374












375



  int32_t type = pRow->type;




251,982,737✔





376



  if (lock) {





251,982,737!





377



    sdbWriteLock(pSdb, type);




252,001,270✔





378



  }










379












380



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




252,115,570✔





381



  sdbPrintOper(pSdb, pRow, "release");




252,154,727✔





382



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





252,136,949✔





383



    sdbFreeRow(pSdb, pRow, true);




56,637✔





384



  }










385



  if (ref < 0) {





252,136,949✔





386



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





3,616!





387



  }










388












389



  if (lock) {





252,135,957✔





390



    sdbUnLock(pSdb, type);




252,131,641✔





391



  }










392



}










393












394



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




252,397,581✔





395












396



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




215,816,104✔





397



  *ppObj = NULL;




215,816,104✔





398












399



  SHashObj *hash = sdbGetHash(pSdb, type);




215,816,104✔





400



  if (hash == NULL) return NULL;





215,809,484✔





401












402



  sdbReadLock(pSdb, type);




215,809,483✔





403












404



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




215,831,052✔





405



  while (ppRow != NULL) {





215,900,263✔





406



    SSdbRow *pRow = *ppRow;




214,098,562✔





407



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





214,098,562!





408



      ppRow = taosHashIterate(hash, ppRow);




54,044✔





409



      continue;




53,716✔





410



    }










411












412



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




214,044,518✔





413












414



    sdbPrintOper(pSdb, pRow, "fetch");




214,042,687✔





415



    *ppObj = pRow->pObj;




214,006,708✔





416



    break;




214,006,708✔





417



  }










418



  sdbUnLock(pSdb, type);




215,808,409✔





419












420



  return ppRow;




215,823,761✔





421



}










422












423



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




1,206,487✔





424



  *ppObj = NULL;




1,206,487✔





425












426



  SHashObj *hash = sdbGetHash(pSdb, type);




1,206,487✔





427



  if (hash == NULL) return NULL;





1,206,468!





428












429



  if (lock) {





1,206,468✔





430



    sdbReadLock(pSdb, type);




1,199,125✔





431



  }










432












433



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




1,206,481✔





434



  while (ppRow != NULL) {





1,206,583✔





435



    SSdbRow *pRow = *ppRow;




1,085,214✔





436



    if (pRow == NULL) {





1,085,214!





437



      ppRow = taosHashIterate(hash, ppRow);




×







438



      continue;




×







439



    }










440












441



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




1,085,214✔





442



    sdbPrintOper(pSdb, pRow, "fetch");




1,085,213✔





443



    *ppObj = pRow->pObj;




1,085,166✔





444



    *status = pRow->status;




1,085,166✔





445



    break;




1,085,166✔





446



  }










447



  if (lock) {





1,206,535✔





448



    sdbUnLock(pSdb, type);




1,199,181✔





449



  }










450












451



  return ppRow;




1,206,491✔





452



}










453












454



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




6,545,159✔





455



  if (pIter == NULL) return;





6,545,159✔





456



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




6,543,155✔





457



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





6,543,155✔





458



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




6,543,155✔





459



  if (hash == NULL) return;





6,543,147!





460












461



  int32_t type = pRow->type;




6,543,147✔





462



  sdbReadLock(pSdb, type);




6,543,147✔





463



  taosHashCancelIterate(hash, pIter);




6,543,188✔





464



  sdbUnLock(pSdb, type);




6,543,200✔





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




737,052✔





479



  SHashObj *hash = sdbGetHash(pSdb, type);




737,052✔





480



  if (hash == NULL) return;





737,053!





481












482



  sdbReadLock(pSdb, type);




737,053✔





483












484



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




737,030✔





485



  while (ppRow != NULL) {





37,430,248✔





486



    SSdbRow *pRow = *ppRow;




36,694,775✔





487



    if (pRow->status == SDB_STATUS_READY) {





36,694,775✔





488



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




36,670,776✔





489



      if (!isContinue) {





36,524,462✔





490



        taosHashCancelIterate(hash, ppRow);




2✔





491



        break;




2✔





492



      }










493



    }










494












495



    ppRow = taosHashIterate(hash, ppRow);




36,548,459✔





496



  }










497












498



  sdbUnLock(pSdb, type);




735,475✔





499



}










500












501



int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {




743,913✔





502



  SHashObj *hash = sdbGetHash(pSdb, type);




743,913✔





503



  if (hash == NULL) return 0;





743,903!





504












505



  sdbReadLock(pSdb, type);




743,903✔





506



  int32_t size = taosHashGetSize(hash);




743,926✔





507



  sdbUnLock(pSdb, type);




743,907✔





508












509



  return size;




743,924✔





510



}










511












512



int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {




62,206✔





513



  SHashObj *hash = sdbGetHash(pSdb, type);




62,206✔





514



  if (hash == NULL) return -1;





62,206✔





515












516



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





62,205✔





517












518



  int32_t maxId = 0;




62,199✔





519



  sdbReadLock(pSdb, type);




62,199✔





520












521



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




62,199✔





522



  while (ppRow != NULL) {





132,122✔





523



    SSdbRow *pRow = *ppRow;




69,923✔





524



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




69,923✔





525



    maxId = TMAX(id, maxId);




69,923✔





526



    ppRow = taosHashIterate(hash, ppRow);




69,923✔





527



  }










528












529



  sdbUnLock(pSdb, type);




62,199✔





530



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




62,199✔





531



  return maxId + 1;




62,199✔





532



}










533












534



int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {




643,109✔





535



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





643,109✔





536



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




1✔





537



    return -1;




1✔





538



  }










539












540



  return pSdb->tableVer[type];




643,108✔





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



}
























    

  • 

    •