taosdata / TDengine / #4833

coverage: 58.533% (-0.06%) from 58.59%
#4833

push

travis-ci

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

# Conflicts:
#	test/ci/run.sh

149243 of 324176 branches covered (46.04%)

Branch coverage included in aggregate %.

198250 of 269498 relevant lines covered (73.56%)

237904970.78 hits per line

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

83.5
/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,221,397,298✔





22



  switch (type) {





1,221,397,298✔





23



    case SDB_TRANS:




174,077,529✔





24



      return "trans";




174,077,529✔





25



    case SDB_CLUSTER:




13,284,275✔





26



      return "cluster";




13,284,275✔





27



    case SDB_MNODE:




14,716,231✔





28



      return "mnode";




14,716,231✔





29



    case SDB_QNODE:




8,238,913✔





30



      return "qnode";




8,238,913✔





31



    case SDB_SNODE:




13,512,418✔





32



      return "snode";




13,512,418✔





33



    case SDB_DNODE:




27,714,287✔





34



      return "dnode";




27,714,287✔





35



    case SDB_USER:




23,018,742✔





36



      return "user";




23,018,742✔





37



    case SDB_AUTH:




584✔





38



      return "auth";




584✔





39



    case SDB_ACCT:




12,659,811✔





40



      return "acct";




12,659,811✔





41



    case SDB_STREAM_CK:




584✔





42



      return "stream_ck";




584✔





43



    case SDB_STREAM:




8,623,377✔





44



      return "stream";




8,623,377✔





45



    case SDB_OFFSET:




584✔





46



      return "offset";




584✔





47



    case SDB_SUBSCRIBE:




9,826,544✔





48



      return "subscribe";




9,826,544✔





49



    case SDB_CONSUMER:




12,102,561✔





50



      return "consumer";




12,102,561✔





51



    case SDB_TOPIC:




9,074,157✔





52



      return "topic";




9,074,157✔





53



    case SDB_VGROUP:




91,881,406✔





54



      return "vgroup";




91,881,406✔





55



    case SDB_SMA:




7,144,338✔





56



      return "sma";




7,144,338✔





57



    case SDB_STB:




114,833,931✔





58



      return "stb";




114,833,931✔





59



    case SDB_DB:




52,739,579✔





60



      return "db";




52,739,579✔





61



    case SDB_FUNC:




7,303,121✔





62



      return "func";




7,303,121✔





63



    case SDB_IDX:




42,661,970✔





64



      return "idx";




42,661,970✔





65



    case SDB_VIEW:




10,199,901✔





66



      return "view";




10,199,901✔





67



    case SDB_STREAM_SEQ:




584✔





68



      return "stream_seq";




584✔





69



    case SDB_COMPACT:




7,607,928✔





70



      return "compact";




7,607,928✔





71



    case SDB_COMPACT_DETAIL:




9,083,544✔





72



      return "compact_detail";




9,083,544✔





73



    case SDB_GRANT:




15,258,264✔





74



      return "grant";




15,258,264✔





75



    case SDB_ARBGROUP:




7,328,783✔





76



      return "arb_group";




7,328,783✔





77



    case SDB_ANODE:




7,144,338✔





78



      return "anode";




7,144,338✔





79



    case SDB_BNODE:




8,560,482✔





80



      return "bnode";




8,560,482✔





81



    case SDB_CFG:




454,530,604✔





82



      return "config";




454,530,604✔





83



    case SDB_MOUNT:




7,169,068✔





84



      return "mount";




7,169,068✔





85



    case SDB_MOUNT_LOG:




7,158,598✔





86



      return "mount_log";




7,158,598✔





87



    case SDB_SSMIGRATE:




7,144,338✔





88



      return "ssmigrate";




7,144,338✔





89



    case SDB_SCAN:




7,171,980✔





90



      return "scan";




7,171,980✔





91



    case SDB_SCAN_DETAIL:




7,185,810✔





92



      return "scan_detail";




7,185,810✔





93



    case SDB_RSMA:




7,419,135✔





94



      return "rsma";




7,419,135✔





95



    default:




15,018,999✔





96



      return "undefine";




15,018,999✔





97



  }










98



}










99












100



const char *sdbStatusName(ESdbStatus status) {




501,613,804✔





101



  switch (status) {





501,613,804!





102



    case SDB_STATUS_CREATING:




26,203,624✔





103



      return "creating";




26,203,624✔





104



    case SDB_STATUS_DROPPING:




7,258,101✔





105



      return "dropping";




7,258,101✔





106



    case SDB_STATUS_READY:




426,691,871✔





107



      return "ready";




426,691,871✔





108



    case SDB_STATUS_DROPPED:




41,215,095✔





109



      return "dropped";




41,215,095✔





110



    case SDB_STATUS_INIT:




245,113✔





111



      return "init";




245,113✔





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





397,430,979!





130



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





397,430,979✔





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,113,554,517✔





158



  } else if (keyType == SDB_KEY_BINARY) {





1,013,992,689✔





159



    keySize = strlen(pKey) + 1;





994,069,295!





160



  } else {










161



    keySize = sizeof(int64_t);




19,923,394✔





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,087,240✔





168



  int32_t type = pRow->type;




285,087,240✔





169



  sdbWriteLock(pSdb, type);




285,087,240✔





170












171



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




285,087,240✔





172



  if (pOldRow != NULL) {





285,087,240!





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,087,240✔





180



  pRow->status = pRaw->status;




285,087,240✔





181



  sdbPrintOper(pSdb, pRow, "insert");




285,087,240✔





182












183



  int32_t code = 0;




285,087,240✔





184



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





285,087,240!





185



    sdbUnLock(pSdb, type);




×







186



    sdbFreeRow(pSdb, pRow, false);




×







187



    return code;




×







188



  }










189












190



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




285,087,240✔





191



  if (insertFp != NULL) {





285,087,240!





192



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




285,087,240✔





193



    if (code != 0) {





285,087,240!





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,087,240✔





205












206



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





285,087,240✔





207



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




69,215,985✔





208



  }










209



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





285,087,240✔





210



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




2,537,451✔





211



  }










212



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




285,087,240✔





213












214



  return 0;




285,087,240✔





215



}










216












217



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




386,645,245✔





218



  int32_t type = pNewRow->type;




386,645,245✔





219



  sdbWriteLock(pSdb, type);




386,645,245✔





220












221



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




386,645,245✔





222



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





386,645,245!





223



    sdbUnLock(pSdb, type);




271,531,815✔





224



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




271,531,815✔





225



  }










226












227



  SSdbRow *pOldRow = *ppOldRow;




115,113,430✔





228



  pOldRow->status = pRaw->status;




115,113,430✔





229



  sdbPrintOper(pSdb, pOldRow, "update");




115,113,430✔





230












231



  int32_t     code = 0;




115,113,430✔





232



  SdbUpdateFp updateFp = pSdb->updateFps[type];




115,113,430✔





233



  if (updateFp != NULL) {





115,113,430!





234



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




115,113,430✔





235



  }










236



  sdbUnLock(pSdb, type);




115,113,430✔





237












238



  // sdbUnLock(pSdb, type);










239



  sdbFreeRow(pSdb, pNewRow, false);




115,113,430✔





240












241



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




115,113,430✔





242



  return code;




115,113,430✔





243



}










244












245



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




66,169,816✔





246



  int32_t type = pRow->type;




66,169,816✔





247



  sdbWriteLock(pSdb, type);




66,169,816✔





248












249



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




66,169,816✔





250



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





66,169,816!





251



    sdbUnLock(pSdb, type);




27,873✔





252



    sdbFreeRow(pSdb, pRow, false);




27,873✔





253



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




27,873✔





254



    return terrno;




27,873✔





255



  }










256



  SSdbRow *pOldRow = *ppOldRow;




66,141,943✔





257



  pOldRow->status = pRaw->status;




66,141,943✔





258












259



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




66,141,943✔





260



  sdbPrintOper(pSdb, pOldRow, "delete");




66,141,943✔





261












262



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





66,141,943!





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





269



  sdbUnLock(pSdb, type);




66,141,943✔





270












271



  sdbFreeRow(pSdb, pRow, false);




66,141,943✔





272












273



  sdbCheckRow(pSdb, pOldRow);




66,141,943✔





274



  return 0;




66,141,943✔





275



}










276












277



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




466,370,486✔





278



  if (pRaw->type == SDB_CFG) {





466,370,486✔





279



    mTrace("sdb write cfg");





179,529,618✔





280



  }










281



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




466,370,486✔





282



  if (hash == NULL) return terrno;





466,370,486!





283












284



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




466,370,486✔





285



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




466,370,486✔





286



  if (pRow == NULL) return terrno;





466,370,486!





287












288



  pRow->type = pRaw->type;




466,370,486✔





289












290



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




466,370,486✔





291



  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;




466,370,486✔





292












293



  switch (pRaw->status) {





466,370,486!





294



    case SDB_STATUS_CREATING:




13,555,425✔





295



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




13,555,425✔





296



      break;




13,555,425✔





297



    case SDB_STATUS_READY:




386,645,245✔





298



    case SDB_STATUS_UPDATE:










299



    case SDB_STATUS_DROPPING:










300



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




386,645,245✔





301



      break;




386,645,245✔





302



    case SDB_STATUS_DROPPED:




66,169,816✔





303



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




66,169,816✔





304



      break;




66,169,816✔





305



  }










306












307



  return code;




466,370,486✔





308



}










309












310



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




52,073,278✔





311



  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);




52,073,278✔





312



  sdbFreeRaw(pRaw);




52,073,278✔





313



  return code;




52,073,278✔





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




539,579,643✔





330



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




539,583,756✔





331



    return NULL;




539,583,756✔





332



  }










333












334



  SSdbRow *pRow = *ppRow;




2,120,608,410✔





335



  switch (pRow->status) {





2,120,609,562!





336



    case SDB_STATUS_READY:




2,113,645,988✔





337



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




2,113,645,988✔





338



      pRet = pRow->pObj;




2,113,648,564✔





339



      sdbPrintOper(pSdb, pRow, "acquire");




2,113,648,538✔





340



      break;




2,113,639,449✔





341



    case SDB_STATUS_CREATING:




5,934,400✔





342



      terrno = TSDB_CODE_SDB_OBJ_CREATING;




5,934,400✔





343



      break;




5,934,400✔





344



    case SDB_STATUS_DROPPING:




1,029,506✔





345



      terrno = TSDB_CODE_SDB_OBJ_DROPPING;




1,029,506✔





346



      break;




1,029,506✔





347



    default:




×







348



      terrno = TSDB_CODE_APP_ERROR;




×







349



      break;




×







350



  }










351












352



  if (pRet == NULL) {





2,120,603,355✔





353



    if (!onlyReady) {





6,963,906!





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,120,603,355✔





362



  return pRet;




2,120,618,437✔





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,355,760✔





367



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




2,355,760✔





368



}










369












370



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




66,141,943✔





371



  int32_t type = pRow->type;




66,141,943✔





372



  sdbWriteLock(pSdb, type);




66,141,943✔





373












374



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




66,141,943✔





375



  sdbPrintOper(pSdb, pRow, "check");




66,141,943✔





376



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





66,141,943!





377



    sdbFreeRow(pSdb, pRow, true);




13,095,879✔





378



  }










379












380



  sdbUnLock(pSdb, type);




66,141,943✔





381



}




66,141,943✔





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,046,064✔





398



  }










399



  if (ref < 0) {





2,147,483,647✔





400



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





3,606,335!





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




26,938,745✔





423



      continue;




26,918,962✔





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




510,940,914✔





438



  *ppObj = NULL;




510,940,914✔





439












440



  SHashObj *hash = sdbGetHash(pSdb, type);




510,940,914✔





441



  if (hash == NULL) return NULL;





510,940,914!





442












443



  if (lock) {





510,940,914✔





444



    sdbReadLock(pSdb, type);




504,447,134✔





445



  }










446












447



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




510,940,914✔





448



  while (ppRow != NULL) {





510,940,914✔





449



    SSdbRow *pRow = *ppRow;




409,388,660✔





450



    if (pRow == NULL) {





409,388,660!





451



      ppRow = taosHashIterate(hash, ppRow);




×







452



      continue;




×







453



    }










454












455



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




409,388,660✔





456



    sdbPrintOper(pSdb, pRow, "fetch");




409,388,660✔





457



    *ppObj = pRow->pObj;




409,388,660✔





458



    *status = pRow->status;




409,388,660✔





459



    break;




409,388,660✔





460



  }










461



  if (lock) {





510,940,914✔





462



    sdbUnLock(pSdb, type);




504,447,134✔





463



  }










464












465



  return ppRow;




510,940,914✔





466



}










467












468



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




314,773,311✔





469



  if (pIter == NULL) return;





314,773,311✔





470



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




314,004,821✔





471



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





314,004,821✔





472



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




314,004,821✔





473



  if (hash == NULL) return;





314,004,821!





474












475



  int32_t type = pRow->type;




314,004,821✔





476



  sdbReadLock(pSdb, type);




314,004,821✔





477



  taosHashCancelIterate(hash, pIter);




314,004,821✔





478



  sdbUnLock(pSdb, type);




314,004,821✔





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,495,504✔





493



  SHashObj *hash = sdbGetHash(pSdb, type);




30,495,504✔





494



  if (hash == NULL) return;





30,495,504!





495












496



  sdbReadLock(pSdb, type);




30,495,504✔





497












498



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




30,495,504✔





499



  while (ppRow != NULL) {





107,702,933✔





500



    SSdbRow *pRow = *ppRow;




77,252,828✔





501



    if (pRow->status == SDB_STATUS_READY) {





77,252,828✔





502



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




70,875,876✔





503



      if (!isContinue) {





70,875,876✔





504



        taosHashCancelIterate(hash, ppRow);




45,399✔





505



        break;




45,399✔





506



      }










507



    }










508












509



    ppRow = taosHashIterate(hash, ppRow);




77,207,429✔





510



  }










511












512



  sdbUnLock(pSdb, type);




30,495,504✔





513



}










514












515



int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {




673,112,941✔





516



  SHashObj *hash = sdbGetHash(pSdb, type);




673,112,941✔





517



  if (hash == NULL) return 0;





673,107,778!





518












519



  sdbReadLock(pSdb, type);




673,107,778✔





520



  int32_t size = taosHashGetSize(hash);




673,115,035✔





521



  sdbUnLock(pSdb, type);




673,093,791✔





522












523



  return size;




673,109,995✔





524



}










525












526



int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {




57,768,073✔





527



  SHashObj *hash = sdbGetHash(pSdb, type);




57,768,073✔





528



  if (hash == NULL) return -1;





57,768,073!





529












530



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





57,768,073!





531












532



  int32_t maxId = 0;




57,768,073✔





533



  sdbReadLock(pSdb, type);




57,768,073✔





534












535



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




57,768,073✔





536



  while (ppRow != NULL) {





98,033,207✔





537



    SSdbRow *pRow = *ppRow;




40,265,134✔





538



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




40,265,134✔





539



    maxId = TMAX(id, maxId);




40,265,134✔





540



    ppRow = taosHashIterate(hash, ppRow);




40,265,134✔





541



  }










542












543



  sdbUnLock(pSdb, type);




57,768,073✔





544



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




57,768,073✔





545



  return maxId + 1;




57,768,073✔





546



}










547












548



int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {




490,275,054✔





549



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





490,275,054!





550



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




×







551



    return -1;




×







552



  }










553












554



  return pSdb->tableVer[type];




490,275,054✔





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




996,572✔





571



  SHashObj *hash = sdbGetHash(pSdb, type);




996,572✔





572



  if (hash == NULL) return false;





996,572!





573



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




996,572✔





574












575



  sdbReadLock(pSdb, type);




996,572✔





576



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




996,572✔





577



  sdbUnLock(pSdb, type);




996,572✔





578












579



  return (NULL != p);




996,572✔





580



}










581












582


























    

  • 

    •