taosdata / TDengine / #4835

coverage: 58.506% (-0.3%) from 58.764%
#4835

push

travis-ci

SallyHuo-TAOS 
Merge remote-tracking branch 'origin/cover/3.0' into cover/3.0

# Conflicts:
#	test/ci/run.sh

149104 of 324176 branches covered (45.99%)

Branch coverage included in aggregate %.

198232 of 269498 relevant lines covered (73.56%)

236558065.91 hits per line

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

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




1,227,326,000✔





22



  switch (type) {





1,227,326,000✔





23



    case SDB_TRANS:




175,831,290✔





24



      return "trans";




175,831,290✔





25



    case SDB_CLUSTER:




13,705,890✔





26



      return "cluster";




13,705,890✔





27



    case SDB_MNODE:




14,788,038✔





28



      return "mnode";




14,788,038✔





29



    case SDB_QNODE:




8,255,691✔





30



      return "qnode";




8,255,691✔





31



    case SDB_SNODE:




13,065,061✔





32



      return "snode";




13,065,061✔





33



    case SDB_DNODE:




28,412,493✔





34



      return "dnode";




28,412,493✔





35



    case SDB_USER:




23,078,424✔





36



      return "user";




23,078,424✔





37



    case SDB_AUTH:




586✔





38



      return "auth";




586✔





39



    case SDB_ACCT:




12,670,888✔





40



      return "acct";




12,670,888✔





41



    case SDB_STREAM_CK:




586✔





42



      return "stream_ck";




586✔





43



    case SDB_STREAM:




8,852,544✔





44



      return "stream";




8,852,544✔





45



    case SDB_OFFSET:




586✔





46



      return "offset";




586✔





47



    case SDB_SUBSCRIBE:




9,882,051✔





48



      return "subscribe";




9,882,051✔





49



    case SDB_CONSUMER:




12,173,471✔





50



      return "consumer";




12,173,471✔





51



    case SDB_TOPIC:




9,102,204✔





52



      return "topic";




9,102,204✔





53



    case SDB_VGROUP:




93,155,178✔





54



      return "vgroup";




93,155,178✔





55



    case SDB_SMA:




7,161,594✔





56



      return "sma";




7,161,594✔





57



    case SDB_STB:




116,416,454✔





58



      return "stb";




116,416,454✔





59



    case SDB_DB:




53,023,735✔





60



      return "db";




53,023,735✔





61



    case SDB_FUNC:




7,318,594✔





62



      return "func";




7,318,594✔





63



    case SDB_IDX:




42,730,322✔





64



      return "idx";




42,730,322✔





65



    case SDB_VIEW:




10,195,620✔





66



      return "view";




10,195,620✔





67



    case SDB_STREAM_SEQ:




586✔





68



      return "stream_seq";




586✔





69



    case SDB_COMPACT:




7,616,961✔





70



      return "compact";




7,616,961✔





71



    case SDB_COMPACT_DETAIL:




8,996,224✔





72



      return "compact_detail";




8,996,224✔





73



    case SDB_GRANT:




15,295,640✔





74



      return "grant";




15,295,640✔





75



    case SDB_ARBGROUP:




7,337,606✔





76



      return "arb_group";




7,337,606✔





77



    case SDB_ANODE:




7,161,594✔





78



      return "anode";




7,161,594✔





79



    case SDB_BNODE:




8,574,618✔





80



      return "bnode";




8,574,618✔





81



    case SDB_CFG:




454,106,245✔





82



      return "config";




454,106,245✔





83



    case SDB_MOUNT:




7,186,527✔





84



      return "mount";




7,186,527✔





85



    case SDB_MOUNT_LOG:




7,175,977✔





86



      return "mount_log";




7,175,977✔





87



    case SDB_SSMIGRATE:




7,161,594✔





88



      return "ssmigrate";




7,161,594✔





89



    case SDB_SCAN:




7,189,284✔





90



      return "scan";




7,189,284✔





91



    case SDB_SCAN_DETAIL:




7,203,129✔





92



      return "scan_detail";




7,203,129✔





93



    case SDB_RSMA:




7,441,863✔





94



      return "rsma";




7,441,863✔





95



    default:




15,056,852✔





96



      return "undefine";




15,056,852✔





97



  }










98



}










99












100



const char *sdbStatusName(ESdbStatus status) {




504,183,941✔





101



  switch (status) {





504,183,941!





102



    case SDB_STATUS_CREATING:




26,213,487✔





103



      return "creating";




26,213,487✔





104



    case SDB_STATUS_DROPPING:




7,260,943✔





105



      return "dropping";




7,260,943✔





106



    case SDB_STATUS_READY:




429,021,774✔





107



      return "ready";




429,021,774✔





108



    case SDB_STATUS_DROPPED:




41,433,218✔





109



      return "dropped";




41,433,218✔





110



    case SDB_STATUS_INIT:




254,519✔





111



      return "init";




254,519✔





112



    case SDB_STATUS_UPDATE:




×







113



      return "update";




×







114



    default:




×







115



      return "undefine";




×







116



  }










117



}










118












119



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




2,147,483,647✔





120



#if 1










121



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




2,147,483,647✔





122












123



  if (keyType == SDB_KEY_BINARY) {





2,147,483,647✔





124



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





2,147,483,647✔





125



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










126



  } else if (keyType == SDB_KEY_INT32) {





2,147,483,647✔





127



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





2,147,483,647✔





128



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










129



  } else if (keyType == SDB_KEY_INT64) {





532,759,303!





130



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





532,759,433✔





131



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










132



  } else {










133



  }










134



#endif










135



}




2,147,483,647✔





136












137



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




2,147,483,647✔





138



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





2,147,483,647!





139



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




×







140



    return NULL;




×







141



  }










142












143



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




2,147,483,647✔





144



  if (hash == NULL) {





2,147,483,647!





145



    terrno = TSDB_CODE_APP_ERROR;




×







146



    return NULL;




×







147



  }










148












149



  return hash;




2,147,483,647✔





150



}










151












152



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




2,147,483,647✔





153



  int32_t  keySize = 0;




2,147,483,647✔





154



  EKeyType keyType = pSdb->keyTypes[type];




2,147,483,647✔





155












156



  if (keyType == SDB_KEY_INT32) {





2,147,483,647✔





157



    keySize = sizeof(int32_t);




2,147,483,647✔





158



  } else if (keyType == SDB_KEY_BINARY) {





1,093,755,868✔





159



    keySize = strlen(pKey) + 1;





1,063,722,168!





160



  } else {










161



    keySize = sizeof(int64_t);




30,033,700✔





162



  }










163












164



  return keySize;




2,147,483,647✔





165



}










166












167



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




285,792,024✔





168



  int32_t type = pRow->type;




285,792,024✔





169



  sdbWriteLock(pSdb, type);




285,792,024✔





170












171



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




285,792,024✔





172



  if (pOldRow != NULL) {





285,792,024!





173



    sdbUnLock(pSdb, type);




×







174



    sdbFreeRow(pSdb, pRow, false);




×







175



    terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;




×







176



    return terrno;




×







177



  }










178












179



  pRow->refCount = 0;




285,792,024✔





180



  pRow->status = pRaw->status;




285,792,024✔





181



  sdbPrintOper(pSdb, pRow, "insert");




285,792,024✔





182












183



  int32_t code = 0;




285,792,024✔





184



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





285,792,024!





185



    sdbUnLock(pSdb, type);




×







186



    sdbFreeRow(pSdb, pRow, false);




×







187



    return code;




×







188



  }










189












190



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




285,792,024✔





191



  if (insertFp != NULL) {





285,792,024!





192



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




285,792,024✔





193



    if (code != 0) {





285,792,024!





194



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





×







195



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





×







196



      }










197



      sdbFreeRow(pSdb, pRow, false);




×







198



      sdbUnLock(pSdb, type);




×







199



      terrno = code;




×







200



      return terrno;




×







201



    }










202



  }










203












204



  sdbUnLock(pSdb, type);




285,792,024✔





205












206



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





285,792,024✔





207



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




69,791,584✔





208



  }










209



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





285,792,024✔





210



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




2,529,507✔





211



  }










212



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




285,792,024✔





213












214



  return 0;




285,792,024✔





215



}










216












217



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




388,616,785✔





218



  int32_t type = pNewRow->type;




388,616,785✔





219



  sdbWriteLock(pSdb, type);




388,616,785✔





220












221



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




388,616,785✔





222



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





388,616,785!





223



    sdbUnLock(pSdb, type);




272,244,936✔





224



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




272,244,936✔





225



  }










226












227



  SSdbRow *pOldRow = *ppOldRow;




116,371,849✔





228



  pOldRow->status = pRaw->status;




116,371,849✔





229



  sdbPrintOper(pSdb, pOldRow, "update");




116,371,849✔





230












231



  int32_t     code = 0;




116,371,849✔





232



  SdbUpdateFp updateFp = pSdb->updateFps[type];




116,371,849✔





233



  if (updateFp != NULL) {





116,371,849!





234



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




116,371,849✔





235



  }










236



  sdbUnLock(pSdb, type);




116,371,849✔





237












238



  // sdbUnLock(pSdb, type);










239



  sdbFreeRow(pSdb, pNewRow, false);




116,371,849✔





240












241



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




116,371,849✔





242



  return code;




116,371,849✔





243



}










244












245



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




66,873,753✔





246



  int32_t type = pRow->type;




66,873,753✔





247



  sdbWriteLock(pSdb, type);




66,873,753✔





248












249



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




66,873,753✔





250



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





66,873,753!





251



    sdbUnLock(pSdb, type);




28,157✔





252



    sdbFreeRow(pSdb, pRow, false);




28,157✔





253



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




28,157✔





254



    return terrno;




28,157✔





255



  }










256



  SSdbRow *pOldRow = *ppOldRow;




66,845,596✔





257



  pOldRow->status = pRaw->status;




66,845,596✔





258












259



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




66,845,596✔





260



  sdbPrintOper(pSdb, pOldRow, "delete");




66,845,596✔





261












262



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





66,845,596!





263



    sdbUnLock(pSdb, type);




×







264



    sdbFreeRow(pSdb, pRow, false);




×







265



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




×







266



    return terrno;




×







267



  }










268



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




66,845,596✔





269



  sdbUnLock(pSdb, type);




66,845,596✔





270












271



  sdbFreeRow(pSdb, pRow, false);




66,845,596✔





272












273



  sdbCheckRow(pSdb, pOldRow);




66,845,596✔





274



  return 0;




66,845,596✔





275



}










276












277



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




469,037,626✔





278



  if (pRaw->type == SDB_CFG) {





469,037,626✔





279



    mTrace("sdb write cfg");





179,448,660✔





280



  }










281



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




469,037,626✔





282



  if (hash == NULL) return terrno;





469,037,626!





283












284



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




469,037,626✔





285



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




469,037,626✔





286



  if (pRow == NULL) return terrno;





469,037,626!





287












288



  pRow->type = pRaw->type;




469,037,626✔





289












290



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




469,037,626✔





291



  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;




469,037,626✔





292












293



  switch (pRaw->status) {





469,037,626!





294



    case SDB_STATUS_CREATING:




13,547,088✔





295



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




13,547,088✔





296



      break;




13,547,088✔





297



    case SDB_STATUS_READY:




388,616,785✔





298



    case SDB_STATUS_UPDATE:










299



    case SDB_STATUS_DROPPING:










300



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




388,616,785✔





301



      break;




388,616,785✔





302



    case SDB_STATUS_DROPPED:




66,873,753✔





303



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




66,873,753✔





304



      break;




66,873,753✔





305



  }










306












307



  return code;




469,037,626✔





308



}










309












310



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




52,690,704✔





311



  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);




52,690,704✔





312



  sdbFreeRaw(pRaw);




52,690,704✔





313



  return code;




52,690,704✔





314



}










315












316



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




2,147,483,647✔





317



  terrno = 0;




2,147,483,647✔





318












319



  SHashObj *hash = sdbGetHash(pSdb, type);




2,147,483,647✔





320



  if (hash == NULL) return NULL;





2,147,483,647!





321












322



  void   *pRet = NULL;




2,147,483,647✔





323



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




2,147,483,647✔





324












325



  sdbReadLock(pSdb, type);




2,147,483,647✔





326












327



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




2,147,483,647✔





328



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





2,147,483,647!





329



    sdbUnLock(pSdb, type);




633,374,439✔





330



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




633,378,223✔





331



    return NULL;




633,378,223✔





332



  }










333












334



  SSdbRow *pRow = *ppRow;




2,147,483,647✔





335



  switch (pRow->status) {





2,147,483,647!





336



    case SDB_STATUS_READY:




2,147,483,647✔





337



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




2,147,483,647✔





338



      pRet = pRow->pObj;




2,147,483,647✔





339



      sdbPrintOper(pSdb, pRow, "acquire");




2,147,483,647✔





340



      break;




2,147,483,647✔





341



    case SDB_STATUS_CREATING:




6,952,679✔





342



      terrno = TSDB_CODE_SDB_OBJ_CREATING;




6,952,679✔





343



      break;




6,952,679✔





344



    case SDB_STATUS_DROPPING:




1,034,186✔





345



      terrno = TSDB_CODE_SDB_OBJ_DROPPING;




1,034,186✔





346



      break;




1,034,186✔





347



    default:




×







348



      terrno = TSDB_CODE_APP_ERROR;




×







349



      break;




×







350



  }










351












352



  if (pRet == NULL) {





2,147,483,647✔





353



    if (!onlyReady) {





7,986,865!





354



      terrno = 0;




×







355



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




×







356



      pRet = pRow->pObj;




×







357



      sdbPrintOper(pSdb, pRow, "acquire");




×







358



    }










359



  }










360












361



  sdbUnLock(pSdb, type);




2,147,483,647✔





362



  return pRet;




2,147,483,647✔





363



}










364












365



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




2,147,483,647✔





366



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




2,361,649✔





367



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




2,361,649✔





368



}










369












370



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




66,845,596✔





371



  int32_t type = pRow->type;




66,845,596✔





372



  sdbWriteLock(pSdb, type);




66,845,596✔





373












374



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




66,845,596✔





375



  sdbPrintOper(pSdb, pRow, "check");




66,845,596✔





376



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





66,845,596!





377



    sdbFreeRow(pSdb, pRow, true);




13,187,518✔





378



  }










379












380



  sdbUnLock(pSdb, type);




66,845,596✔





381



}




66,845,596✔





382












383



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




2,147,483,647✔





384



  if (pObj == NULL) return;





2,147,483,647✔





385












386



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




2,147,483,647✔





387



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





2,147,483,647!





388












389



  int32_t type = pRow->type;




2,147,483,647✔





390



  if (lock) {





2,147,483,647✔





391



    sdbWriteLock(pSdb, type);




2,147,483,647✔





392



  }










393












394



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




2,147,483,647✔





395



  sdbPrintOper(pSdb, pRow, "release");




2,147,483,647✔





396



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





2,147,483,647✔





397



    sdbFreeRow(pSdb, pRow, true);




53,658,078✔





398



  }










399



  if (ref < 0) {





2,147,483,647✔





400



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





3,667,282!





401



  }










402












403



  if (lock) {





2,147,483,647✔





404



    sdbUnLock(pSdb, type);




2,147,483,647✔





405



  }










406



}










407












408



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




2,147,483,647✔





409












410



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




2,147,483,647✔





411



  *ppObj = NULL;




2,147,483,647✔





412












413



  SHashObj *hash = sdbGetHash(pSdb, type);




2,147,483,647✔





414



  if (hash == NULL) return NULL;





2,147,483,647!





415












416



  sdbReadLock(pSdb, type);




2,147,483,647✔





417












418



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




2,147,483,647✔





419



  while (ppRow != NULL) {





2,147,483,647✔





420



    SSdbRow *pRow = *ppRow;




2,147,483,647✔





421



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





2,147,483,647✔





422



      ppRow = taosHashIterate(hash, ppRow);




29,386,475✔





423



      continue;




29,371,930✔





424



    }










425












426



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




2,147,483,647✔





427












428



    sdbPrintOper(pSdb, pRow, "fetch");




2,147,483,647✔





429



    *ppObj = pRow->pObj;




2,147,483,647✔





430



    break;




2,147,483,647✔





431



  }










432



  sdbUnLock(pSdb, type);




2,147,483,647✔





433












434



  return ppRow;




2,147,483,647✔





435



}










436












437



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




592,852,904✔





438



  *ppObj = NULL;




592,852,904✔





439












440



  SHashObj *hash = sdbGetHash(pSdb, type);




592,852,904✔





441



  if (hash == NULL) return NULL;





592,852,904!





442












443



  if (lock) {





592,852,904✔





444



    sdbReadLock(pSdb, type);




586,387,305✔





445



  }










446












447



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




592,852,904✔





448



  while (ppRow != NULL) {





592,852,904✔





449



    SSdbRow *pRow = *ppRow;




474,926,723✔





450



    if (pRow == NULL) {





474,926,723!





451



      ppRow = taosHashIterate(hash, ppRow);




×







452



      continue;




×







453



    }










454












455



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




474,926,723✔





456



    sdbPrintOper(pSdb, pRow, "fetch");




474,926,723✔





457



    *ppObj = pRow->pObj;




474,926,723✔





458



    *status = pRow->status;




474,926,723✔





459



    break;




474,926,723✔





460



  }










461



  if (lock) {





592,852,904✔





462



    sdbUnLock(pSdb, type);




586,387,305✔





463



  }










464












465



  return ppRow;




592,852,904✔





466



}










467












468



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




376,732,939✔





469



  if (pIter == NULL) return;





376,732,939✔





470



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




375,960,615✔





471



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





375,962,254✔





472



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




375,962,254✔





473



  if (hash == NULL) return;





375,962,254!





474












475



  int32_t type = pRow->type;




375,962,254✔





476



  sdbReadLock(pSdb, type);




375,962,254✔





477



  taosHashCancelIterate(hash, pIter);




375,962,254✔





478



  sdbUnLock(pSdb, type);




375,962,254✔





479



}










480












481



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




×







482



  if (pIter == NULL) return;





×







483



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





×







484



  SHashObj *hash = sdbGetHash(pSdb, type);




×







485



  if (hash == NULL) return;





×







486












487



  sdbReadLock(pSdb, type);




×







488



  taosHashCancelIterate(hash, pIter);




×







489



  sdbUnLock(pSdb, type);




×







490



}










491












492



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




30,518,329✔





493



  SHashObj *hash = sdbGetHash(pSdb, type);




30,518,329✔





494



  if (hash == NULL) return;





30,518,329!





495












496



  sdbReadLock(pSdb, type);




30,518,329✔





497












498



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




30,518,329✔





499



  while (ppRow != NULL) {





110,132,928✔





500



    SSdbRow *pRow = *ppRow;




79,657,458✔





501



    if (pRow->status == SDB_STATUS_READY) {





79,657,458✔





502



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




73,234,082✔





503



      if (!isContinue) {





73,234,082✔





504



        taosHashCancelIterate(hash, ppRow);




42,859✔





505



        break;




42,859✔





506



      }










507



    }










508












509



    ppRow = taosHashIterate(hash, ppRow);




79,614,599✔





510



  }










511












512



  sdbUnLock(pSdb, type);




30,518,329✔





513



}










514












515



int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {




829,098,780✔





516



  SHashObj *hash = sdbGetHash(pSdb, type);




829,098,780✔





517



  if (hash == NULL) return 0;





829,100,463!





518












519



  sdbReadLock(pSdb, type);




829,100,463✔





520



  int32_t size = taosHashGetSize(hash);




829,104,836✔





521



  sdbUnLock(pSdb, type);




829,093,638✔





522












523



  return size;




829,104,463✔





524



}










525












526



int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {




57,994,774✔





527



  SHashObj *hash = sdbGetHash(pSdb, type);




57,994,774✔





528



  if (hash == NULL) return -1;





57,994,774!





529












530



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





57,994,774!





531












532



  int32_t maxId = 0;




57,994,774✔





533



  sdbReadLock(pSdb, type);




57,994,774✔





534












535



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




57,994,774✔





536



  while (ppRow != NULL) {





96,323,177✔





537



    SSdbRow *pRow = *ppRow;




38,328,403✔





538



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




38,328,403✔





539



    maxId = TMAX(id, maxId);




38,328,403✔





540



    ppRow = taosHashIterate(hash, ppRow);




38,328,403✔





541



  }










542












543



  sdbUnLock(pSdb, type);




57,994,774✔





544



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




57,994,774✔





545



  return maxId + 1;




57,994,774✔





546



}










547












548



int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {




657,601,894✔





549



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





657,601,894!





550



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




×







551



    return -1;




×







552



  }










553












554



  return pSdb->tableVer[type];




657,601,894✔





555



}










556












557



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




×







558



  int32_t *pInt = p1;




×







559



  (*pInt) += 1;




×







560



  return true;




×







561



}










562












563



int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {




×







564



  int32_t num = 0;




×







565



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




×







566



  return num;




×







567



}










568












569












570



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




1,231,553✔





571



  SHashObj *hash = sdbGetHash(pSdb, type);




1,231,553✔





572



  if (hash == NULL) return false;





1,231,553!





573



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




1,231,553✔





574












575



  sdbReadLock(pSdb, type);




1,231,553✔





576



  void* p = taosHashGet(hash, pKey, keySize);




1,231,553✔





577



  sdbUnLock(pSdb, type);




1,231,553✔





578












579



  return (NULL != p);




1,231,553✔





580



}










581












582


























    

  • 

    •