taosdata / TDengine / #5097

coverage: 73.316% (+0.04%) from 73.276%
#5097

push

travis-ci

web-flow 
feat (TDgpt): Dynamic Model Synchronization Enhancements (#35344)

* refactor: do some internal refactor.

* fix: fix multiprocess sync issue.

* feat: add dynamic anomaly detection and forecasting services

* fix: log error message for undeploying model in exception handling

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* fix: handle undeploy when model exists only on disk

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/286aafa0-c3ce-4c27-b803-2707571e9dc1

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: guard dynamic registry concurrent access

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: tighten service list locking scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: restore prophet support and update tests per review feedback

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: improve test name and move copy inside lock scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* Potential fix for pull request finding

Co-au... (continued)

281382 of 383795 relevant lines covered (73.32%)

132379014.15 hits per line

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

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




525,073,029✔





22



  switch (type) {




525,073,029✔





23



    case SDB_TRANS:




78,167,231✔





24



      return "trans";




78,167,231✔





25



    case SDB_CLUSTER:




4,727,180✔





26



      return "cluster";




4,727,180✔





27



    case SDB_MNODE:




4,655,450✔





28



      return "mnode";




4,655,450✔





29



    case SDB_QNODE:




2,266,181✔





30



      return "qnode";




2,266,181✔





31



    case SDB_SNODE:




4,097,096✔





32



      return "snode";




4,097,096✔





33



    case SDB_DNODE:




9,225,002✔





34



      return "dnode";




9,225,002✔





35



    case SDB_USER:




15,634,960✔





36



      return "user";




15,634,960✔





37



    case SDB_AUTH:




122✔





38



      return "auth";




122✔





39



    case SDB_ACCT:




3,905,545✔





40



      return "acct";




3,905,545✔





41



    case SDB_STREAM_CK:




122✔





42



      return "stream_ck";




122✔





43



    case SDB_STREAM:




3,372,544✔





44



      return "stream";




3,372,544✔





45



    case SDB_OFFSET:




122✔





46



      return "offset";




122✔





47



    case SDB_SUBSCRIBE:




3,617,472✔





48



      return "subscribe";




3,617,472✔





49



    case SDB_CONSUMER:




4,785,279✔





50



      return "consumer";




4,785,279✔





51



    case SDB_TOPIC:




3,139,847✔





52



      return "topic";




3,139,847✔





53



    case SDB_VGROUP:




36,858,279✔





54



      return "vgroup";




36,858,279✔





55



    case SDB_SMA:




2,246,852✔





56



      return "sma";




2,246,852✔





57



    case SDB_STB:




50,093,338✔





58



      return "stb";




50,093,338✔





59



    case SDB_DB:




29,795,966✔





60



      return "db";




29,795,966✔





61



    case SDB_FUNC:




2,306,027✔





62



      return "func";




2,306,027✔





63



    case SDB_IDX:




13,549,958✔





64



      return "idx";




13,549,958✔





65



    case SDB_VIEW:




3,340,778✔





66



      return "view";




3,340,778✔





67



    case SDB_STREAM_SEQ:




122✔





68



      return "stream_seq";




122✔





69



    case SDB_COMPACT:




2,443,338✔





70



      return "compact";




2,443,338✔





71



    case SDB_COMPACT_DETAIL:




3,289,045✔





72



      return "compact_detail";




3,289,045✔





73



    case SDB_GRANT:




4,707,118✔





74



      return "grant";




4,707,118✔





75



    case SDB_ARBGROUP:




2,282,078✔





76



      return "arb_group";




2,282,078✔





77



    case SDB_ANODE:




2,194,835✔





78



      return "anode";




2,194,835✔





79



    case SDB_BNODE:




2,534,872✔





80



      return "bnode";




2,534,872✔





81



    case SDB_XNODE:




2,224,143✔





82



      return "xnode";




2,224,143✔





83



    case SDB_CFG:




165,691,911✔





84



      return "config";




165,691,911✔





85



    case SDB_MOUNT:




2,199,222✔





86



      return "mount";




2,199,222✔





87



    case SDB_MOUNT_LOG:




2,197,364✔





88



      return "mount_log";




2,197,364✔





89



    case SDB_SSMIGRATE:




2,301,647✔





90



      return "ssmigrate";




2,301,647✔





91



    case SDB_SCAN:




2,198,969✔





92



      return "scan";




2,198,969✔





93



    case SDB_SCAN_DETAIL:




2,204,476✔





94



      return "scan_detail";




2,204,476✔





95



    case SDB_RSMA:




2,467,427✔





96



      return "rsma";




2,467,427✔





97



    case SDB_RETENTION:




2,379,198✔





98



      return "retention";




2,379,198✔





99



    case SDB_RETENTION_DETAIL:




2,623,501✔





100



      return "retention_detail";




2,623,501✔





101



    case SDB_INSTANCE:




1,207,413✔





102



      return "instance";




1,207,413✔





103



    case SDB_ENCRYPT_ALGORITHMS:




13,946,830✔





104



      return "encrypt_algr";




13,946,830✔





105



    case SDB_TOKEN:




2,277,128✔





106



      return "token";




2,277,128✔





107



    case SDB_ROLE:




11,668,966✔





108



      return "role";




11,668,966✔





109



    case SDB_XNODE_TASK:




2,195,231✔





110



      return "xnode_task";




2,195,231✔





111



    case SDB_XNODE_AGENT:




2,232,723✔





112



      return "xnode_agent";




2,232,723✔





113



    case SDB_XNODE_JOB:




2,195,231✔





114



      return "xnode_job";




2,195,231✔





115



    case SDB_XNODE_USER_PASS:




2,199,719✔





116



      return "xnode_user_pass";




2,199,719✔





117



    case SDB_SECURITY_POLICY:




5,229,940✔





118



      return "security_policy";




5,229,940✔





119



    case SDB_GRANT_CLS:




2,194,835✔





120



      return "grant_cls";




2,194,835✔





121



    default:




396✔





122



      return "undefine";




396✔





123



  }










124



}










125












126



const char *sdbStatusName(ESdbStatus status) {




215,218,520✔





127



  switch (status) {




215,218,520✔





128



    case SDB_STATUS_CREATING:




10,100,436✔





129



      return "creating";




10,100,436✔





130



    case SDB_STATUS_DROPPING:




2,972,135✔





131



      return "dropping";




2,972,135✔





132



    case SDB_STATUS_READY:




183,975,998✔





133



      return "ready";




183,975,998✔





134



    case SDB_STATUS_DROPPED:




17,853,774✔





135



      return "dropped";




17,853,774✔





136



    case SDB_STATUS_INIT:




315,979✔





137



      return "init";




315,979✔





138



    case SDB_STATUS_UPDATE:




×







139



      return "update";




×







140



    default:




198✔





141



      return "undefine";




198✔





142



  }










143



}










144












145



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




2,147,483,647✔





146



#if 1










147



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




2,147,483,647✔





148












149



  if (keyType == SDB_KEY_BINARY) {




2,147,483,647✔





150



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




2,015,870,890✔





151



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










152



  } else if (keyType == SDB_KEY_INT32) {




2,147,483,647✔





153



    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✔





154



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










155



  } else if (keyType == SDB_KEY_INT64) {




201,580,452✔





156



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




201,580,452✔





157



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










158



  } else {










159



  }










160



#endif










161



}




2,147,483,647✔





162












163



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




2,147,483,647✔





164



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




2,147,483,647✔





165



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




198✔





166



    return NULL;




198✔





167



  }










168












169



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




2,147,483,647✔





170



  if (hash == NULL) {




2,147,483,647✔





171



    terrno = TSDB_CODE_APP_ERROR;




198✔





172



    return NULL;




198✔





173



  }










174












175



  return hash;




2,147,483,647✔





176



}










177












178



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




1,550,010,222✔





179



  int32_t  keySize = 0;




1,550,010,222✔





180



  EKeyType keyType = pSdb->keyTypes[type];




1,550,010,222✔





181












182



  if (keyType == SDB_KEY_INT32) {




1,550,010,991✔





183



    keySize = sizeof(int32_t);




918,087,150✔





184



  } else if (keyType == SDB_KEY_BINARY) {




631,923,841✔





185



    keySize = strlen(pKey) + 1;




605,306,331✔





186



  } else {










187



    keySize = sizeof(int64_t);




26,617,510✔





188



  }










189












190



  return keySize;




1,550,010,991✔





191



}










192












193



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




112,380,363✔





194



  int32_t type = pRow->type;




112,380,363✔





195



  sdbWriteLock(pSdb, type);




112,380,363✔





196












197



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




112,380,363✔





198



  if (pOldRow != NULL) {




112,380,363✔





199



    sdbUnLock(pSdb, type);




×







200



    sdbFreeRow(pSdb, pRow, false);




×







201



    terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;




×







202



    return terrno;




×







203



  }










204












205



  pRow->refCount = 0;




112,380,363✔





206



  pRow->status = pRaw->status;




112,380,363✔





207



  sdbPrintOper(pSdb, pRow, "insert");




112,380,363✔





208












209



  int32_t code = 0;




112,380,363✔





210



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




112,380,363✔





211



    sdbUnLock(pSdb, type);




×







212



    sdbFreeRow(pSdb, pRow, false);




×







213



    return code;




×







214



  }










215












216



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




112,380,363✔





217



  if (insertFp != NULL) {




112,380,363✔





218



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




112,380,363✔





219



    if (code != 0) {




112,380,363✔





220



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




×







221



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




×







222



      }










223



      sdbFreeRow(pSdb, pRow, false);




×







224



      sdbUnLock(pSdb, type);




×







225



      terrno = code;




×







226



      return terrno;




×







227



    }










228



  }










229












230



  sdbUnLock(pSdb, type);




112,380,363✔





231












232



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




112,380,363✔





233



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




33,270,898✔





234



  }










235



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




112,380,363✔





236



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




967,604✔





237



  }










238



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




112,380,363✔





239












240



  return 0;




112,380,363✔





241



}










242












243



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




159,981,938✔





244



  int32_t type = pNewRow->type;




159,981,938✔





245



  sdbWriteLock(pSdb, type);




159,981,938✔





246












247



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




159,981,938✔





248



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




159,981,938✔





249



    sdbUnLock(pSdb, type);




107,246,373✔





250



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




107,246,373✔





251



  }










252












253



  SSdbRow *pOldRow = *ppOldRow;




52,735,565✔





254



  pOldRow->status = pRaw->status;




52,735,565✔





255



  sdbPrintOper(pSdb, pOldRow, "update");




52,735,565✔





256












257



  int32_t     code = 0;




52,735,565✔





258



  SdbUpdateFp updateFp = pSdb->updateFps[type];




52,735,565✔





259



  if (updateFp != NULL) {




52,735,565✔





260



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




52,735,565✔





261



  }










262



  sdbUnLock(pSdb, type);




52,735,565✔





263












264



  // sdbUnLock(pSdb, type);










265



  sdbFreeRow(pSdb, pNewRow, false);




52,735,565✔





266












267



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




52,735,565✔





268



  return code;




52,735,565✔





269



}










270












271



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




29,633,738✔





272



  int32_t type = pRow->type;




29,633,738✔





273



  sdbWriteLock(pSdb, type);




29,633,738✔





274












275



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




29,633,738✔





276



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




29,633,738✔





277



    sdbUnLock(pSdb, type);




13,870✔





278



    sdbFreeRow(pSdb, pRow, false);




13,870✔





279



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




13,870✔





280



    return terrno;




13,870✔





281



  }










282



  SSdbRow *pOldRow = *ppOldRow;




29,619,868✔





283



  pOldRow->status = pRaw->status;




29,619,868✔





284












285



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




29,619,868✔





286



  sdbPrintOper(pSdb, pOldRow, "delete");




29,619,868✔





287












288



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




29,619,868✔





289



    sdbUnLock(pSdb, type);




×







290



    sdbFreeRow(pSdb, pRow, false);




×







291



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




×







292



    return terrno;




×







293



  }










294



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




29,619,868✔





295



  sdbUnLock(pSdb, type);




29,619,868✔





296












297



  sdbFreeRow(pSdb, pRow, false);




29,619,868✔





298












299



  sdbCheckRow(pSdb, pOldRow);




29,619,868✔





300



  return 0;




29,619,868✔





301



}










302












303



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




194,750,062✔





304



  if (pRaw->type == SDB_CFG) {




194,750,062✔





305



    mTrace("sdb write cfg");




65,124,016✔





306



  }










307



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




194,750,062✔





308



  if (hash == NULL) return terrno;




194,750,062✔





309












310



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




194,749,666✔





311



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




194,749,666✔





312



  if (pRow == NULL) return terrno;




194,749,666✔





313












314



  pRow->type = pRaw->type;




194,749,666✔





315












316



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




194,749,666✔





317



  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;




194,749,666✔





318












319



  switch (pRaw->status) {




194,749,666✔





320



    case SDB_STATUS_CREATING:




5,133,990✔





321



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




5,133,990✔





322



      break;




5,133,990✔





323



    case SDB_STATUS_READY:




159,981,938✔





324



    case SDB_STATUS_UPDATE:










325



    case SDB_STATUS_DROPPING:










326



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




159,981,938✔





327



      break;




159,981,938✔





328



    case SDB_STATUS_DROPPED:




29,633,738✔





329



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




29,633,738✔





330



      break;




29,633,738✔





331



  }










332












333



  return code;




194,749,666✔





334



}










335












336



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




23,547,452✔





337



  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);




23,547,452✔





338



  sdbFreeRaw(pRaw);




23,547,452✔





339



  return code;




23,547,452✔





340



}










341












342



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




1,354,883,499✔





343



  terrno = 0;




1,354,883,499✔





344












345



  SHashObj *hash = sdbGetHash(pSdb, type);




1,354,883,787✔





346



  if (hash == NULL) return NULL;




1,354,880,076✔





347












348



  void   *pRet = NULL;




1,354,880,076✔





349



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




1,354,880,076✔





350












351



  sdbReadLock(pSdb, type);




1,354,878,120✔





352












353



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




1,354,882,116✔





354



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




1,354,882,966✔





355



    sdbUnLock(pSdb, type);




255,150,296✔





356



    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;




255,150,621✔





357



    return NULL;




255,150,621✔





358



  }










359












360



  SSdbRow *pRow = *ppRow;




1,099,732,229✔





361



  switch (pRow->status) {




1,099,730,722✔





362



    case SDB_STATUS_READY:




1,098,304,640✔





363



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




1,098,304,640✔





364



      pRet = pRow->pObj;




1,098,305,063✔





365



      sdbPrintOper(pSdb, pRow, "acquire");




1,098,305,463✔





366



      break;




1,098,303,575✔





367



    case SDB_STATUS_CREATING:




948,786✔





368



      terrno = TSDB_CODE_SDB_OBJ_CREATING;




948,786✔





369



      break;




948,786✔





370



    case SDB_STATUS_DROPPING:




480,111✔





371



      terrno = TSDB_CODE_SDB_OBJ_DROPPING;




480,111✔





372



      break;




480,111✔





373



    default:




×







374



      terrno = TSDB_CODE_APP_ERROR;




×







375



      break;




×







376



  }










377












378



  if (pRet == NULL) {




1,099,732,472✔





379



    if (!onlyReady) {




1,428,897✔





380



      terrno = 0;




×







381



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




×







382



      pRet = pRow->pObj;




×







383



      sdbPrintOper(pSdb, pRow, "acquire");




×







384



    }










385



  }










386












387



  sdbUnLock(pSdb, type);




1,099,732,472✔





388



  return pRet;




1,099,732,591✔





389



}










390












391



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




1,354,247,820✔





392



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




635,857✔





393



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




635,857✔





394



}










395












396



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




29,619,868✔





397



  int32_t type = pRow->type;




29,619,868✔





398



  sdbWriteLock(pSdb, type);




29,619,868✔





399












400



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




29,619,868✔





401



  sdbPrintOper(pSdb, pRow, "check");




29,619,868✔





402



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




29,619,868✔





403



    sdbFreeRow(pSdb, pRow, true);




5,616,603✔





404



  }










405












406



  sdbUnLock(pSdb, type);




29,619,868✔





407



}




29,619,868✔





408












409



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




2,147,483,647✔





410



  if (pObj == NULL) return;




2,147,483,647✔





411












412



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




2,147,483,647✔





413



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




2,147,483,647✔





414












415



  int32_t type = pRow->type;




2,147,483,647✔





416



  if (lock) {




2,147,483,647✔





417



    sdbWriteLock(pSdb, type);




2,147,483,647✔





418



  }










419












420



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




2,147,483,647✔





421



  sdbPrintOper(pSdb, pRow, "release");




2,147,483,647✔





422



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




2,147,483,647✔





423



    sdbFreeRow(pSdb, pRow, true);




24,003,265✔





424



  }










425



  if (ref < 0) {




2,147,483,647✔





426



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




9,500,577✔





427



  }










428












429



  if (lock) {




2,147,483,647✔





430



    sdbUnLock(pSdb, type);




2,147,483,647✔





431



  }










432



}










433












434



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




2,147,483,647✔





435












436



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




1,411,956,962✔





437



  *ppObj = NULL;




1,411,956,962✔





438












439



  SHashObj *hash = sdbGetHash(pSdb, type);




1,411,957,999✔





440



  if (hash == NULL) return NULL;




1,411,951,891✔





441












442



  sdbReadLock(pSdb, type);




1,411,951,891✔





443












444



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




1,411,956,413✔





445



  while (ppRow != NULL) {




1,420,596,927✔





446



    SSdbRow *pRow = *ppRow;




997,488,310✔





447



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




997,489,587✔





448



      ppRow = taosHashIterate(hash, ppRow);




8,639,225✔





449



      continue;




8,640,048✔





450



    }










451












452



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




988,847,100✔





453












454



    sdbPrintOper(pSdb, pRow, "fetch");




988,848,964✔





455



    *ppObj = pRow->pObj;




988,843,582✔





456



    break;




988,843,548✔





457



  }










458



  sdbUnLock(pSdb, type);




1,411,952,165✔





459












460



  return ppRow;




1,411,955,110✔





461



}










462












463



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




377,082,340✔





464



  *ppObj = NULL;




377,082,340✔





465












466



  SHashObj *hash = sdbGetHash(pSdb, type);




377,082,340✔





467



  if (hash == NULL) return NULL;




377,082,340✔





468












469



  if (lock) {




377,082,340✔





470



    sdbReadLock(pSdb, type);




375,504,380✔





471



  }










472












473



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




377,082,340✔





474



  while (ppRow != NULL) {




377,082,340✔





475



    SSdbRow *pRow = *ppRow;




273,866,835✔





476



    if (pRow == NULL) {




273,866,835✔





477



      ppRow = taosHashIterate(hash, ppRow);




×







478



      continue;




×







479



    }










480












481



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




273,866,835✔





482



    sdbPrintOper(pSdb, pRow, "fetch");




273,866,835✔





483



    *ppObj = pRow->pObj;




273,866,835✔





484



    *status = pRow->status;




273,866,835✔





485



    break;




273,866,835✔





486



  }










487



  if (lock) {




377,082,340✔





488



    sdbUnLock(pSdb, type);




375,504,380✔





489



  }










490












491



  return ppRow;




377,082,340✔





492



}










493












494



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




158,435,845✔





495



  if (pIter == NULL) return;




158,435,845✔





496



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




136,656,091✔





497



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




136,656,091✔





498



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




136,656,091✔





499



  if (hash == NULL) return;




136,656,091✔





500












501



  int32_t type = pRow->type;




136,656,091✔





502



  sdbReadLock(pSdb, type);




136,656,091✔





503



  taosHashCancelIterate(hash, pIter);




136,656,091✔





504



  sdbUnLock(pSdb, type);




136,656,091✔





505



}










506












507



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




200✔





508



  if (pIter == NULL) return;




200✔





509



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




200✔





510



  SHashObj *hash = sdbGetHash(pSdb, type);




200✔





511



  if (hash == NULL) return;




200✔





512












513



  sdbReadLock(pSdb, type);




200✔





514



  taosHashCancelIterate(hash, pIter);




200✔





515



  sdbUnLock(pSdb, type);




200✔





516



}










517












518



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




11,847,059✔





519



  SHashObj *hash = sdbGetHash(pSdb, type);




11,847,059✔





520



  if (hash == NULL) return;




11,847,059✔





521












522



  sdbReadLock(pSdb, type);




11,847,059✔





523












524



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




11,847,059✔





525



  while (ppRow != NULL) {




46,558,673✔





526



    SSdbRow *pRow = *ppRow;




34,723,847✔





527



    if (pRow->status == SDB_STATUS_READY) {




34,723,847✔





528



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




33,934,859✔





529



      if (!isContinue) {




33,934,859✔





530



        taosHashCancelIterate(hash, ppRow);




12,233✔





531



        break;




12,233✔





532



      }










533



    }










534












535



    ppRow = taosHashIterate(hash, ppRow);




34,711,614✔





536



  }










537












538



  sdbUnLock(pSdb, type);




11,847,059✔





539



}










540












541



int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {




293,450,872✔





542



  SHashObj *hash = sdbGetHash(pSdb, type);




293,450,872✔





543



  if (hash == NULL) return 0;




293,450,977✔





544












545



  sdbReadLock(pSdb, type);




293,450,977✔





546



  int32_t size = taosHashGetSize(hash);




293,448,079✔





547



  sdbUnLock(pSdb, type);




293,444,982✔





548












549



  return size;




293,451,762✔





550



}










551












552



int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {




27,067,378✔





553



  SHashObj *hash = sdbGetHash(pSdb, type);




27,067,378✔





554



  if (hash == NULL) return -1;




27,067,378✔





555












556



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




27,067,378✔





557












558



  int32_t maxId = 0;




27,066,190✔





559



  sdbReadLock(pSdb, type);




27,066,190✔





560












561



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




27,066,190✔





562



  while (ppRow != NULL) {




44,704,278✔





563



    SSdbRow *pRow = *ppRow;




17,638,088✔





564



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




17,638,088✔





565



    maxId = TMAX(id, maxId);




17,638,088✔





566



    ppRow = taosHashIterate(hash, ppRow);




17,638,088✔





567



  }










568












569



  sdbUnLock(pSdb, type);




27,066,190✔





570



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




27,066,190✔





571



  return maxId + 1;




27,066,190✔





572



}










573












574



int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {




202,807,470✔





575



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




202,807,470✔





576



    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;




198✔





577



    return -1;




198✔





578



  }










579












580



  return pSdb->tableVer[type];




202,807,272✔





581



}










582












583



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




×







584



  int32_t *pInt = p1;




×







585



  (*pInt) += 1;




×







586



  return true;




×







587



}










588












589



int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {




×







590



  int32_t num = 0;




×







591



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




×







592



  return num;




×







593



}










594












595












596



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




381,007✔





597



  SHashObj *hash = sdbGetHash(pSdb, type);




381,007✔





598



  if (hash == NULL) return false;




381,007✔





599



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




381,007✔





600












601



  sdbReadLock(pSdb, type);




381,007✔





602



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




381,007✔





603



  sdbUnLock(pSdb, type);




381,007✔





604












605



  return (NULL != p);




381,007✔





606



}










607












608


























    

  • 

    •