taosdata/TDengine | Build 4824 | source/dnode/mnode/sdb/src/sdbHash.c | Coveralls

21

const char *sdbTableName(ESdbType type) {

1,075,497,631✔

22

  switch (type) {

1,075,497,631✔

23

    case SDB_TRANS:

153,874,940✔

24

      return "trans";

153,874,940✔

25

    case SDB_CLUSTER:

11,660,273✔

26

      return "cluster";

11,660,273✔

27

    case SDB_MNODE:

12,920,408✔

28

      return "mnode";

12,920,408✔

29

    case SDB_QNODE:

7,126,247✔

30

      return "qnode";

7,126,247✔

31

    case SDB_SNODE:

11,625,290✔

32

      return "snode";

11,625,290✔

33

    case SDB_DNODE:

25,821,280✔

34

      return "dnode";

25,821,280✔

35

    case SDB_USER:

20,317,715✔

36

      return "user";

20,317,715✔

37

    case SDB_AUTH:

604✔

38

      return "auth";

604✔

39

    case SDB_ACCT:

11,165,847✔

40

      return "acct";

11,165,847✔

41

    case SDB_STREAM_CK:

604✔

42

      return "stream_ck";

604✔

43

    case SDB_STREAM:

7,909,265✔

44

      return "stream";

7,909,265✔

45

    case SDB_OFFSET:

604✔

46

      return "offset";

604✔

47

    case SDB_SUBSCRIBE:

8,540,654✔

48

      return "subscribe";

8,540,654✔

49

    case SDB_CONSUMER:

10,418,735✔

50

      return "consumer";

10,418,735✔

51

    case SDB_TOPIC:

7,910,450✔

52

      return "topic";

7,910,450✔

53

    case SDB_VGROUP:

80,688,842✔

54

      return "vgroup";

80,688,842✔

55

    case SDB_SMA:

6,298,412✔

56

      return "sma";

6,298,412✔

57

    case SDB_STB:

100,119,653✔

58

      return "stb";

100,119,653✔

59

    case SDB_DB:

46,760,978✔

60

      return "db";

46,760,978✔

61

    case SDB_FUNC:

6,433,991✔

62

      return "func";

6,433,991✔

63

    case SDB_IDX:

37,194,129✔

64

      return "idx";

37,194,129✔

65

    case SDB_VIEW:

8,967,050✔

66

      return "view";

8,967,050✔

67

    case SDB_STREAM_SEQ:

604✔

68

      return "stream_seq";

604✔

69

    case SDB_COMPACT:

6,636,119✔

70

      return "compact";

6,636,119✔

71

    case SDB_COMPACT_DETAIL:

7,704,983✔

72

      return "compact_detail";

7,704,983✔

73

    case SDB_GRANT:

13,447,986✔

74

      return "grant";

13,447,986✔

75

    case SDB_ARBGROUP:

6,501,580✔

76

      return "arb_group";

6,501,580✔

77

    case SDB_ANODE:

6,298,412✔

78

      return "anode";

6,298,412✔

79

    case SDB_BNODE:

7,586,755✔

80

      return "bnode";

7,586,755✔

81

    case SDB_CFG:

400,339,300✔

82

      return "config";

400,339,300✔

83

    case SDB_MOUNT:

6,319,101✔

84

      return "mount";

6,319,101✔

85

    case SDB_MOUNT_LOG:

6,310,347✔

86

      return "mount_log";

6,310,347✔

87

    case SDB_SSMIGRATE:

6,298,412✔

88

      return "ssmigrate";

6,298,412✔

89

    case SDB_SCAN:

6,321,284✔

90

      return "scan";

6,321,284✔

91

    case SDB_SCAN_DETAIL:

6,332,729✔

92

      return "scan_detail";

6,332,729✔

93

    case SDB_RSMA:

6,490,787✔

94

      return "rsma";

6,490,787✔

95

    default:

13,153,261✔

96

      return "undefine";

13,153,261✔

100

const char *sdbStatusName(ESdbStatus status) {

441,663,219✔

102

    case SDB_STATUS_CREATING:

23,030,125✔

103

      return "creating";

23,030,125✔

104

    case SDB_STATUS_DROPPING:

6,533,650✔

105

      return "dropping";

6,533,650✔

106

    case SDB_STATUS_READY:

375,249,062✔

107

      return "ready";

375,249,062✔

108

    case SDB_STATUS_DROPPED:

36,608,175✔

109

      return "dropped";

36,608,175✔

110

    case SDB_STATUS_INIT:

242,168✔

111

      return "init";

242,168✔

114

    default:

39✔

115

      return "undefine";

39✔

119

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

2,147,483,647✔

121

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

2,147,483,647✔

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✔

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✔

129

  } else if (keyType == SDB_KEY_INT64) {

322,205,621✔

130

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

322,205,325✔

135

2,147,483,647✔

137

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

2,147,483,647✔

139

    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;

39✔

140

    return NULL;

39✔

143

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

2,147,483,647✔

144

  if (hash == NULL) {

2,147,483,647✔

145

    terrno = TSDB_CODE_APP_ERROR;

39✔

146

    return NULL;

39✔

149

  return hash;

2,147,483,647✔

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✔

156

  if (keyType == SDB_KEY_INT32) {

2,147,483,647✔

157

    keySize = sizeof(int32_t);

1,786,904,112✔

158

  } else if (keyType == SDB_KEY_BINARY) {

1,017,248,469✔

161

    keySize = sizeof(int64_t);

15,793,813✔

164

  return keySize;

2,147,483,647✔

167

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

250,216,492✔

168

  int32_t type = pRow->type;

250,216,492✔

169

  sdbWriteLock(pSdb, type);

250,216,492✔

171

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

250,216,492✔

179

  pRow->refCount = 0;

250,216,492✔

180

  pRow->status = pRaw->status;

250,216,492✔

181

  sdbPrintOper(pSdb, pRow, "insert");

250,216,492✔

183

  int32_t code = 0;

250,216,492✔

190

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

250,216,492✔

192

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

250,216,492✔

204

  sdbUnLock(pSdb, type);

250,216,492✔

206

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

250,216,492✔

207

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

60,950,042✔

209

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

250,216,492✔

210

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

2,165,269✔

212

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

250,216,492✔

214

  return 0;

250,216,492✔

217

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

339,902,045✔

218

  int32_t type = pNewRow->type;

339,902,045✔

219

  sdbWriteLock(pSdb, type);

339,902,045✔

221

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

339,902,045✔

223

    sdbUnLock(pSdb, type);

238,348,393✔

224

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

238,348,393✔

227

  SSdbRow *pOldRow = *ppOldRow;

101,553,652✔

228

  pOldRow->status = pRaw->status;

101,553,652✔

229

  sdbPrintOper(pSdb, pOldRow, "update");

101,553,652✔

231

  int32_t     code = 0;

101,553,652✔

232

  SdbUpdateFp updateFp = pSdb->updateFps[type];

101,553,652✔

234

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

101,553,652✔

236

  sdbUnLock(pSdb, type);

101,553,652✔

239

  sdbFreeRow(pSdb, pNewRow, false);

101,553,652✔

241

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

101,553,652✔

242

  return code;

101,553,652✔

245

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

58,523,653✔

246

  int32_t type = pRow->type;

58,523,653✔

247

  sdbWriteLock(pSdb, type);

58,523,653✔

249

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

58,523,653✔

251

    sdbUnLock(pSdb, type);

23,411✔

252

    sdbFreeRow(pSdb, pRow, false);

23,411✔

253

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

23,411✔

254

    return terrno;

23,411✔

256

  SSdbRow *pOldRow = *ppOldRow;

58,500,242✔

257

  pOldRow->status = pRaw->status;

58,500,242✔

259

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

58,500,242✔

260

  sdbPrintOper(pSdb, pOldRow, "delete");

58,500,242✔

268

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

58,500,242✔

269

  sdbUnLock(pSdb, type);

58,500,242✔

271

  sdbFreeRow(pSdb, pRow, false);

58,500,242✔

273

  sdbCheckRow(pSdb, pOldRow);

58,500,242✔

274

  return 0;

58,500,242✔

277

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

410,293,875✔

278

  if (pRaw->type == SDB_CFG) {

410,293,875✔

279

    mTrace("sdb write cfg");

157,731,937✔

281

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

410,293,875✔

282

  if (hash == NULL) return terrno;

410,293,875✔

284

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

410,293,797✔

285

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

410,293,797✔

288

  pRow->type = pRaw->type;

410,293,797✔

290

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

410,293,797✔

291

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

410,293,797✔

294

    case SDB_STATUS_CREATING:

11,868,099✔

295

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

11,868,099✔

296

      break;

11,868,099✔

297

    case SDB_STATUS_READY:

339,902,045✔

300

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

339,902,045✔

301

      break;

339,902,045✔

302

    case SDB_STATUS_DROPPED:

58,523,653✔

303

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

58,523,653✔

304

      break;

58,523,653✔

307

  return code;

410,293,797✔

310

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

46,016,510✔

311

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

46,016,510✔

312

  sdbFreeRaw(pRaw);

46,016,510✔

313

  return code;

46,016,510✔

316

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

2,147,483,647✔

317

  terrno = 0;

2,147,483,647✔

319

  SHashObj *hash = sdbGetHash(pSdb, type);

2,147,483,647✔

322

  void   *pRet = NULL;

2,147,483,647✔

323

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

2,147,483,647✔

325

  sdbReadLock(pSdb, type);

2,147,483,647✔

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

478,281,845✔

330

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

478,281,840✔

331

    return NULL;

478,281,840✔

334

  SSdbRow *pRow = *ppRow;

1,914,562,388✔

336

    case SDB_STATUS_READY:

1,908,673,809✔

337

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

1,908,673,809✔

338

      pRet = pRow->pObj;

1,908,674,538✔

339

      sdbPrintOper(pSdb, pRow, "acquire");

1,908,674,960✔

340

      break;

1,908,671,091✔

341

    case SDB_STATUS_CREATING:

5,032,370✔

342

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

5,032,370✔

343

      break;

5,032,370✔

344

    case SDB_STATUS_DROPPING:

859,246✔

345

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

859,246✔

346

      break;

859,246✔

352

  if (pRet == NULL) {

1,914,562,707✔

353

    if (!onlyReady) {

5,891,616✔

354

      terrno = 0;

800✔

355

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

800✔

356

      pRet = pRow->pObj;

800✔

357

      sdbPrintOper(pSdb, pRow, "acquire");

800✔

361

  sdbUnLock(pSdb, type);

1,914,562,707✔

362

  return pRet;

1,914,563,501✔

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,049,173✔

367

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

2,049,173✔

370

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

58,500,242✔

371

  int32_t type = pRow->type;

58,500,242✔

372

  sdbWriteLock(pSdb, type);

58,500,242✔

374

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

58,500,242✔

375

  sdbPrintOper(pSdb, pRow, "check");

58,500,242✔

377

    sdbFreeRow(pSdb, pRow, true);

11,667,747✔

380

  sdbUnLock(pSdb, type);

58,500,242✔

381

58,500,242✔

383

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

2,147,483,647✔

384

  if (pObj == NULL) return;

2,147,483,647✔

386

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

2,147,483,647✔

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✔

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

46,832,495✔

399

  if (ref < 0) {

2,147,483,647✔

403

  if (lock) {

2,147,483,647✔

404

    sdbUnLock(pSdb, type);

2,147,483,647✔

408

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

2,147,483,647✔

410

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

2,147,483,647✔

411

  *ppObj = NULL;

2,147,483,647✔

413

  SHashObj *hash = sdbGetHash(pSdb, type);

2,147,483,647✔

416

  sdbReadLock(pSdb, type);

2,147,483,647✔

418

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

2,147,483,647✔

419

  while (ppRow != NULL) {

2,147,483,647✔

420

    SSdbRow *pRow = *ppRow;

1,904,367,386✔

422

      ppRow = taosHashIterate(hash, ppRow);

16,660,826✔

423

      continue;

16,635,049✔

426

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

1,887,707,923✔

428

    sdbPrintOper(pSdb, pRow, "fetch");

1,887,719,097✔

429

    *ppObj = pRow->pObj;

1,887,692,739✔

430

    break;

1,887,709,349✔

432

  sdbUnLock(pSdb, type);

2,147,483,647✔

434

  return ppRow;

2,147,483,647✔

437

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

435,412,035✔

438

  *ppObj = NULL;

435,412,035✔

440

  SHashObj *hash = sdbGetHash(pSdb, type);

435,412,035✔

443

  if (lock) {

435,412,035✔

444

    sdbReadLock(pSdb, type);

429,828,842✔

447

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

435,412,035✔

448

  while (ppRow != NULL) {

435,412,035✔

449

    SSdbRow *pRow = *ppRow;

349,231,469✔

455

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

349,231,469✔

456

    sdbPrintOper(pSdb, pRow, "fetch");

349,231,469✔

457

    *ppObj = pRow->pObj;

349,231,469✔

458

    *status = pRow->status;

349,231,469✔

459

    break;

349,231,469✔

461

  if (lock) {

435,412,035✔

462

    sdbUnLock(pSdb, type);

429,828,842✔

465

  return ppRow;

435,412,035✔

468

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

280,570,253✔

469

  if (pIter == NULL) return;

280,570,253✔

470

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

279,929,553✔

471

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

279,929,553✔

472

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

279,929,553✔

475

  int32_t type = pRow->type;

279,929,553✔

476

  sdbReadLock(pSdb, type);

279,929,553✔

477

  taosHashCancelIterate(hash, pIter);

279,929,553✔

478

  sdbUnLock(pSdb, type);

279,929,553✔

492

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

27,115,409✔

493

  SHashObj *hash = sdbGetHash(pSdb, type);

27,115,409✔

496

  sdbReadLock(pSdb, type);

27,115,409✔

498

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

27,115,409✔

499

  while (ppRow != NULL) {

94,988,980✔

500

    SSdbRow *pRow = *ppRow;

67,910,333✔

501

    if (pRow->status == SDB_STATUS_READY) {

67,910,333✔

502

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

62,315,165✔

503

      if (!isContinue) {

62,315,165✔

504

        taosHashCancelIterate(hash, ppRow);

36,762✔

505

        break;

36,762✔

509

    ppRow = taosHashIterate(hash, ppRow);

67,873,571✔

512

  sdbUnLock(pSdb, type);

27,115,409✔

515

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

598,946,304✔

516

  SHashObj *hash = sdbGetHash(pSdb, type);

598,946,304✔

519

  sdbReadLock(pSdb, type);

598,942,571✔

520

  int32_t size = taosHashGetSize(hash);

598,954,395✔

521

  sdbUnLock(pSdb, type);

598,939,894✔

523

  return size;

598,955,880✔

526

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

51,056,634✔

527

  SHashObj *hash = sdbGetHash(pSdb, type);

51,056,634✔

530

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

51,056,634✔

532

  int32_t maxId = 0;

51,056,400✔

533

  sdbReadLock(pSdb, type);

51,056,400✔

535

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

51,056,400✔

536

  while (ppRow != NULL) {

84,488,156✔

537

    SSdbRow *pRow = *ppRow;

33,431,756✔

538

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

33,431,756✔

539

    maxId = TMAX(id, maxId);

33,431,756✔

540

    ppRow = taosHashIterate(hash, ppRow);

33,431,756✔

543

  sdbUnLock(pSdb, type);

51,056,400✔

544

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

51,056,400✔

545

  return maxId + 1;

51,056,400✔

548

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

397,078,556✔

549

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

397,078,556✔

550

    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;

39✔

551

    return -1;

39✔

554

  return pSdb->tableVer[type];

397,078,517✔

570

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

1,021,327✔

571

  SHashObj *hash = sdbGetHash(pSdb, type);

1,021,327✔

573

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

1,021,327✔

575

  sdbReadLock(pSdb, type);

1,021,327✔

576

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

1,021,327✔

577

  sdbUnLock(pSdb, type);

1,021,327✔

579

  return (NULL != p);

1,021,327✔

taosdata / TDengine / #4824

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

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,075,497,631✔
22	switch (type) {	1,075,497,631✔
23	case SDB_TRANS:	153,874,940✔
24	return "trans";	153,874,940✔
25	case SDB_CLUSTER:	11,660,273✔
26	return "cluster";	11,660,273✔
27	case SDB_MNODE:	12,920,408✔
28	return "mnode";	12,920,408✔
29	case SDB_QNODE:	7,126,247✔
30	return "qnode";	7,126,247✔
31	case SDB_SNODE:	11,625,290✔
32	return "snode";	11,625,290✔
33	case SDB_DNODE:	25,821,280✔
34	return "dnode";	25,821,280✔
35	case SDB_USER:	20,317,715✔
36	return "user";	20,317,715✔
37	case SDB_AUTH:	604✔
38	return "auth";	604✔
39	case SDB_ACCT:	11,165,847✔
40	return "acct";	11,165,847✔
41	case SDB_STREAM_CK:	604✔
42	return "stream_ck";	604✔
43	case SDB_STREAM:	7,909,265✔
44	return "stream";	7,909,265✔
45	case SDB_OFFSET:	604✔
46	return "offset";	604✔
47	case SDB_SUBSCRIBE:	8,540,654✔
48	return "subscribe";	8,540,654✔
49	case SDB_CONSUMER:	10,418,735✔
50	return "consumer";	10,418,735✔
51	case SDB_TOPIC:	7,910,450✔
52	return "topic";	7,910,450✔
53	case SDB_VGROUP:	80,688,842✔
54	return "vgroup";	80,688,842✔
55	case SDB_SMA:	6,298,412✔
56	return "sma";	6,298,412✔
57	case SDB_STB:	100,119,653✔
58	return "stb";	100,119,653✔
59	case SDB_DB:	46,760,978✔
60	return "db";	46,760,978✔
61	case SDB_FUNC:	6,433,991✔
62	return "func";	6,433,991✔
63	case SDB_IDX:	37,194,129✔
64	return "idx";	37,194,129✔
65	case SDB_VIEW:	8,967,050✔
66	return "view";	8,967,050✔
67	case SDB_STREAM_SEQ:	604✔
68	return "stream_seq";	604✔
69	case SDB_COMPACT:	6,636,119✔
70	return "compact";	6,636,119✔
71	case SDB_COMPACT_DETAIL:	7,704,983✔
72	return "compact_detail";	7,704,983✔
73	case SDB_GRANT:	13,447,986✔
74	return "grant";	13,447,986✔
75	case SDB_ARBGROUP:	6,501,580✔
76	return "arb_group";	6,501,580✔
77	case SDB_ANODE:	6,298,412✔
78	return "anode";	6,298,412✔
79	case SDB_BNODE:	7,586,755✔
80	return "bnode";	7,586,755✔
81	case SDB_CFG:	400,339,300✔
82	return "config";	400,339,300✔
83	case SDB_MOUNT:	6,319,101✔
84	return "mount";	6,319,101✔
85	case SDB_MOUNT_LOG:	6,310,347✔
86	return "mount_log";	6,310,347✔
87	case SDB_SSMIGRATE:	6,298,412✔
88	return "ssmigrate";	6,298,412✔
89	case SDB_SCAN:	6,321,284✔
90	return "scan";	6,321,284✔
91	case SDB_SCAN_DETAIL:	6,332,729✔
92	return "scan_detail";	6,332,729✔
93	case SDB_RSMA:	6,490,787✔
94	return "rsma";	6,490,787✔
95	default:	13,153,261✔
96	return "undefine";	13,153,261✔
97	}
98	}
99
100	const char *sdbStatusName(ESdbStatus status) {	441,663,219✔
101	switch (status) {	441,663,219!
102	case SDB_STATUS_CREATING:	23,030,125✔
103	return "creating";	23,030,125✔
104	case SDB_STATUS_DROPPING:	6,533,650✔
105	return "dropping";	6,533,650✔
106	case SDB_STATUS_READY:	375,249,062✔
107	return "ready";	375,249,062✔
108	case SDB_STATUS_DROPPED:	36,608,175✔
109	return "dropped";	36,608,175✔
110	case SDB_STATUS_INIT:	242,168✔
111	return "init";	242,168✔
112	case SDB_STATUS_UPDATE:	×
113	return "update";	×
114	default:	39✔
115	return "undefine";	39✔
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) {	322,205,621✔
130	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	322,205,325✔
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;	39✔
140	return NULL;	39✔
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;	39✔
146	return NULL;	39✔
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);	1,786,904,112✔
158	} else if (keyType == SDB_KEY_BINARY) {	1,017,248,469✔
159	keySize = strlen(pKey) + 1;	1,001,454,656!
160	} else {
161	keySize = sizeof(int64_t);	15,793,813✔
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) {	250,216,492✔
168	int32_t type = pRow->type;	250,216,492✔
169	sdbWriteLock(pSdb, type);	250,216,492✔
170
171	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	250,216,492✔
172	if (pOldRow != NULL) {	250,216,492!
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;	250,216,492✔
180	pRow->status = pRaw->status;	250,216,492✔
181	sdbPrintOper(pSdb, pRow, "insert");	250,216,492✔
182
183	int32_t code = 0;	250,216,492✔
184	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	250,216,492!
185	sdbUnLock(pSdb, type);	×
186	sdbFreeRow(pSdb, pRow, false);	×
187	return code;	×
188	}
189
190	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	250,216,492✔
191	if (insertFp != NULL) {	250,216,492!
192	code = (*insertFp)(pSdb, pRow->pObj);	250,216,492✔
193	if (code != 0) {	250,216,492!
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);	250,216,492✔
205
206	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	250,216,492✔
207	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	60,950,042✔
208	}
209	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	250,216,492✔
210	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	2,165,269✔
211	}
212	pSdb->tableVer[pRow->type]++;	250,216,492✔
213
214	return 0;	250,216,492✔
215	}
216
217	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	339,902,045✔
218	int32_t type = pNewRow->type;	339,902,045✔
219	sdbWriteLock(pSdb, type);	339,902,045✔
220
221	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	339,902,045✔
222	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	339,902,045!
223	sdbUnLock(pSdb, type);	238,348,393✔
224	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	238,348,393✔
225	}
226
227	SSdbRow pOldRow = ppOldRow;	101,553,652✔
228	pOldRow->status = pRaw->status;	101,553,652✔
229	sdbPrintOper(pSdb, pOldRow, "update");	101,553,652✔
230
231	int32_t code = 0;	101,553,652✔
232	SdbUpdateFp updateFp = pSdb->updateFps[type];	101,553,652✔
233	if (updateFp != NULL) {	101,553,652!
234	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	101,553,652✔
235	}
236	sdbUnLock(pSdb, type);	101,553,652✔
237
238	// sdbUnLock(pSdb, type);
239	sdbFreeRow(pSdb, pNewRow, false);	101,553,652✔
240
241	pSdb->tableVer[pOldRow->type]++;	101,553,652✔
242	return code;	101,553,652✔
243	}
244
245	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	58,523,653✔
246	int32_t type = pRow->type;	58,523,653✔
247	sdbWriteLock(pSdb, type);	58,523,653✔
248
249	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	58,523,653✔
250	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	58,523,653!
251	sdbUnLock(pSdb, type);	23,411✔
252	sdbFreeRow(pSdb, pRow, false);	23,411✔
253	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	23,411✔
254	return terrno;	23,411✔
255	}
256	SSdbRow pOldRow = ppOldRow;	58,500,242✔
257	pOldRow->status = pRaw->status;	58,500,242✔
258
259	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	58,500,242✔
260	sdbPrintOper(pSdb, pOldRow, "delete");	58,500,242✔
261
262	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	58,500,242!
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]++;	58,500,242✔
269	sdbUnLock(pSdb, type);	58,500,242✔
270
271	sdbFreeRow(pSdb, pRow, false);	58,500,242✔
272
273	sdbCheckRow(pSdb, pOldRow);	58,500,242✔
274	return 0;	58,500,242✔
275	}
276
277	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	410,293,875✔
278	if (pRaw->type == SDB_CFG) {	410,293,875✔
279	mTrace("sdb write cfg");	157,731,937✔
280	}
281	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	410,293,875✔
282	if (hash == NULL) return terrno;	410,293,875✔
283
284	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	410,293,797✔
285	SSdbRow pRow = (decodeFp)(pRaw);	410,293,797✔
286	if (pRow == NULL) return terrno;	410,293,797!
287
288	pRow->type = pRaw->type;	410,293,797✔
289
290	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	410,293,797✔
291	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	410,293,797✔
292
293	switch (pRaw->status) {	410,293,797!
294	case SDB_STATUS_CREATING:	11,868,099✔
295	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	11,868,099✔
296	break;	11,868,099✔
297	case SDB_STATUS_READY:	339,902,045✔
298	case SDB_STATUS_UPDATE:
299	case SDB_STATUS_DROPPING:
300	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	339,902,045✔
301	break;	339,902,045✔
302	case SDB_STATUS_DROPPED:	58,523,653✔
303	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	58,523,653✔
304	break;	58,523,653✔
305	}
306
307	return code;	410,293,797✔
308	}
309
310	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	46,016,510✔
311	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	46,016,510✔
312	sdbFreeRaw(pRaw);	46,016,510✔
313	return code;	46,016,510✔
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);	478,281,845✔
330	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	478,281,840✔
331	return NULL;	478,281,840✔
332	}
333
334	SSdbRow pRow = ppRow;	1,914,562,388✔
335	switch (pRow->status) {	1,914,562,806!
336	case SDB_STATUS_READY:	1,908,673,809✔
337	(void)atomic_add_fetch_32(&pRow->refCount, 1);	1,908,673,809✔
338	pRet = pRow->pObj;	1,908,674,538✔
339	sdbPrintOper(pSdb, pRow, "acquire");	1,908,674,960✔
340	break;	1,908,671,091✔
341	case SDB_STATUS_CREATING:	5,032,370✔
342	terrno = TSDB_CODE_SDB_OBJ_CREATING;	5,032,370✔
343	break;	5,032,370✔
344	case SDB_STATUS_DROPPING:	859,246✔
345	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	859,246✔
346	break;	859,246✔
347	default:	×
348	terrno = TSDB_CODE_APP_ERROR;	×
349	break;	×
350	}
351
352	if (pRet == NULL) {	1,914,562,707✔
353	if (!onlyReady) {	5,891,616✔
354	terrno = 0;	800✔
355	(void)atomic_add_fetch_32(&pRow->refCount, 1);	800✔
356	pRet = pRow->pObj;	800✔
357	sdbPrintOper(pSdb, pRow, "acquire");	800✔
358	}
359	}
360
361	sdbUnLock(pSdb, type);	1,914,562,707✔
362	return pRet;	1,914,563,501✔
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,049,173✔
367	return sdbAcquireAll(pSdb, type, pKey, false);	2,049,173✔
368	}
369
370	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	58,500,242✔
371	int32_t type = pRow->type;	58,500,242✔
372	sdbWriteLock(pSdb, type);	58,500,242✔
373
374	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	58,500,242✔
375	sdbPrintOper(pSdb, pRow, "check");	58,500,242✔
376	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	58,500,242!
377	sdbFreeRow(pSdb, pRow, true);	11,667,747✔
378	}
379
380	sdbUnLock(pSdb, type);	58,500,242✔
381	}	58,500,242✔
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);	46,832,495✔
398	}
399	if (ref < 0) {	2,147,483,647✔
400	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	3,148,275!
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;	1,904,367,386✔
421	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	1,904,370,520!
422	ppRow = taosHashIterate(hash, ppRow);	16,660,826✔
423	continue;	16,635,049✔
424	}
425
426	(void) atomic_add_fetch_32(&pRow->refCount, 1);	1,887,707,923✔
427
428	sdbPrintOper(pSdb, pRow, "fetch");	1,887,719,097✔
429	*ppObj = pRow->pObj;	1,887,692,739✔
430	break;	1,887,709,349✔
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) {	435,412,035✔
438	*ppObj = NULL;	435,412,035✔
439
440	SHashObj *hash = sdbGetHash(pSdb, type);	435,412,035✔
441	if (hash == NULL) return NULL;	435,412,035!
442
443	if (lock) {	435,412,035✔
444	sdbReadLock(pSdb, type);	429,828,842✔
445	}
446
447	SSdbRow **ppRow = taosHashIterate(hash, pIter);	435,412,035✔
448	while (ppRow != NULL) {	435,412,035✔
449	SSdbRow pRow = ppRow;	349,231,469✔
450	if (pRow == NULL) {	349,231,469!
451	ppRow = taosHashIterate(hash, ppRow);	×
452	continue;	×
453	}
454
455	(void)atomic_add_fetch_32(&pRow->refCount, 1);	349,231,469✔
456	sdbPrintOper(pSdb, pRow, "fetch");	349,231,469✔
457	*ppObj = pRow->pObj;	349,231,469✔
458	*status = pRow->status;	349,231,469✔
459	break;	349,231,469✔
460	}
461	if (lock) {	435,412,035✔
462	sdbUnLock(pSdb, type);	429,828,842✔
463	}
464
465	return ppRow;	435,412,035✔
466	}
467
468	void sdbCancelFetch(SSdb pSdb, void pIter) {	280,570,253✔
469	if (pIter == NULL) return;	280,570,253✔
470	SSdbRow pRow = (SSdbRow **)pIter;	279,929,553✔
471	mTrace("cancel fetch row:%p", pRow);	279,929,553✔
472	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	279,929,553✔
473	if (hash == NULL) return;	279,929,553!
474
475	int32_t type = pRow->type;	279,929,553✔
476	sdbReadLock(pSdb, type);	279,929,553✔
477	taosHashCancelIterate(hash, pIter);	279,929,553✔
478	sdbUnLock(pSdb, type);	279,929,553✔
479	}
480
UNCOV 481	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	×
UNCOV 482	if (pIter == NULL) return;	×
UNCOV 483	if (type >= SDB_MAX \|\| type < 0) return;	×
UNCOV 484	SHashObj *hash = sdbGetHash(pSdb, type);	×
UNCOV 485	if (hash == NULL) return;	×
486
UNCOV 487	sdbReadLock(pSdb, type);	×
UNCOV 488	taosHashCancelIterate(hash, pIter);	×
UNCOV 489	sdbUnLock(pSdb, type);	×
490	}
491
492	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	27,115,409✔
493	SHashObj *hash = sdbGetHash(pSdb, type);	27,115,409✔
494	if (hash == NULL) return;	27,115,409!
495
496	sdbReadLock(pSdb, type);	27,115,409✔
497
498	SSdbRow **ppRow = taosHashIterate(hash, NULL);	27,115,409✔
499	while (ppRow != NULL) {	94,988,980✔
500	SSdbRow pRow = ppRow;	67,910,333✔
501	if (pRow->status == SDB_STATUS_READY) {	67,910,333✔
502	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	62,315,165✔
503	if (!isContinue) {	62,315,165✔
504	taosHashCancelIterate(hash, ppRow);	36,762✔
505	break;	36,762✔
506	}
507	}
508
509	ppRow = taosHashIterate(hash, ppRow);	67,873,571✔
510	}
511
512	sdbUnLock(pSdb, type);	27,115,409✔
513	}
514
515	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	598,946,304✔
516	SHashObj *hash = sdbGetHash(pSdb, type);	598,946,304✔
517	if (hash == NULL) return 0;	598,942,571!
518
519	sdbReadLock(pSdb, type);	598,942,571✔
520	int32_t size = taosHashGetSize(hash);	598,954,395✔
521	sdbUnLock(pSdb, type);	598,939,894✔
522
523	return size;	598,955,880✔
524	}
525
526	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	51,056,634✔
527	SHashObj *hash = sdbGetHash(pSdb, type);	51,056,634✔
528	if (hash == NULL) return -1;	51,056,634!
529
530	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	51,056,634✔
531
532	int32_t maxId = 0;	51,056,400✔
533	sdbReadLock(pSdb, type);	51,056,400✔
534
535	SSdbRow **ppRow = taosHashIterate(hash, NULL);	51,056,400✔
536	while (ppRow != NULL) {	84,488,156✔
537	SSdbRow pRow = ppRow;	33,431,756✔
538	int32_t id = (int32_t )pRow->pObj;	33,431,756✔
539	maxId = TMAX(id, maxId);	33,431,756✔
540	ppRow = taosHashIterate(hash, ppRow);	33,431,756✔
541	}
542
543	sdbUnLock(pSdb, type);	51,056,400✔
544	maxId = TMAX(maxId, pSdb->maxId[type]);	51,056,400✔
545	return maxId + 1;	51,056,400✔
546	}
547
548	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	397,078,556✔
549	if (type >= SDB_MAX \|\| type < 0) {	397,078,556✔
550	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	39✔
551	return -1;	39✔
552	}
553
554	return pSdb->tableVer[type];	397,078,517✔
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,021,327✔
571	SHashObj *hash = sdbGetHash(pSdb, type);	1,021,327✔
572	if (hash == NULL) return false;	1,021,327!
573	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	1,021,327✔
574
575	sdbReadLock(pSdb, type);	1,021,327✔
576	void* p = taosHashGet(hash, pKey, keySize);	1,021,327✔
577	sdbUnLock(pSdb, type);	1,021,327✔
578
579	return (NULL != p);	1,021,327✔
580	}
581
582

taosdata / TDengine / #4824

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

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