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

21

const char *sdbTableName(ESdbType type) {

196,699,770✔

22

  switch (type) {

196,699,770✔

23

    case SDB_TRANS:

31,044,329✔

24

      return "trans";

31,044,329✔

25

    case SDB_CLUSTER:

1,779,934✔

26

      return "cluster";

1,779,934✔

27

    case SDB_MNODE:

1,862,110✔

28

      return "mnode";

1,862,110✔

29

    case SDB_QNODE:

979,464✔

30

      return "qnode";

979,464✔

31

    case SDB_SNODE:

982,440✔

32

      return "snode";

982,440✔

33

    case SDB_DNODE:

3,396,804✔

34

      return "dnode";

3,396,804✔

35

    case SDB_USER:

3,716,081✔

36

      return "user";

3,716,081✔

37

    case SDB_AUTH:

102✔

38

      return "auth";

102✔

39

    case SDB_ACCT:

1,703,062✔

40

      return "acct";

1,703,062✔

41

    case SDB_STREAM_CK:

102✔

42

      return "stream_ck";

102✔

43

    case SDB_STREAM:

987,799✔

44

      return "stream";

987,799✔

45

    case SDB_OFFSET:

102✔

46

      return "offset";

102✔

47

    case SDB_SUBSCRIBE:

1,045,663✔

48

      return "subscribe";

1,045,663✔

49

    case SDB_CONSUMER:

1,131,517✔

50

      return "consumer";

1,131,517✔

51

    case SDB_TOPIC:

1,022,455✔

52

      return "topic";

1,022,455✔

53

    case SDB_VGROUP:

16,040,201✔

54

      return "vgroup";

16,040,201✔

55

    case SDB_SMA:

967,765✔

56

      return "sma";

967,765✔

57

    case SDB_STB:

28,587,616✔

58

      return "stb";

28,587,616✔

59

    case SDB_DB:

9,774,759✔

60

      return "db";

9,774,759✔

61

    case SDB_FUNC:

1,009,337✔

62

      return "func";

1,009,337✔

63

    case SDB_IDX:

5,425,795✔

64

      return "idx";

5,425,795✔

65

    case SDB_VIEW:

1,559,146✔

66

      return "view";

1,559,146✔

67

    case SDB_STREAM_SEQ:

102✔

68

      return "stream_seq";

102✔

69

    case SDB_COMPACT:

1,114,549✔

70

      return "compact";

1,114,549✔

71

    case SDB_COMPACT_DETAIL:

1,516,087✔

72

      return "compact_detail";

1,516,087✔

73

    case SDB_GRANT:

2,026,501✔

74

      return "grant";

2,026,501✔

75

    case SDB_ARBGROUP:

1,021,395✔

76

      return "arb_group";

1,021,395✔

77

    case SDB_ANODE:

967,765✔

78

      return "anode";

967,765✔

79

    case SDB_BNODE:

1,203,792✔

80

      return "bnode";

1,203,792✔

81

    case SDB_CFG:

62,637,491✔

82

      return "config";

62,637,491✔

83

    case SDB_MOUNT:

972,112✔

84

      return "mount";

972,112✔

85

    case SDB_MOUNT_LOG:

970,267✔

86

      return "mount_log";

970,267✔

87

    case SDB_SSMIGRATE:

967,765✔

88

      return "ssmigrate";

967,765✔

89

    case SDB_SCAN:

968,251✔

90

      return "scan";

968,251✔

91

    case SDB_SCAN_DETAIL:

968,476✔

92

      return "scan_detail";

968,476✔

93

    case SDB_RSMA:

1,070,014✔

94

      return "rsma";

1,070,014✔

95

    case SDB_INSTANCE:

540,860✔

96

      return "instance";

540,860✔

97

    case SDB_ENCRYPT_ALGORITHMS:

4,593,139✔

98

      return "encrypt_algr";

4,593,139✔

99

    default:

2,144,621✔

100

      return "undefine";

2,144,621✔

104

const char *sdbStatusName(ESdbStatus status) {

82,998,038✔

105

  switch (status) {

82,998,038✔

106

    case SDB_STATUS_CREATING:

4,202,453✔

107

      return "creating";

4,202,453✔

108

    case SDB_STATUS_DROPPING:

1,488,696✔

109

      return "dropping";

1,488,696✔

110

    case SDB_STATUS_READY:

69,405,212✔

111

      return "ready";

69,405,212✔

112

    case SDB_STATUS_DROPPED:

7,847,677✔

113

      return "dropped";

7,847,677✔

114

    case SDB_STATUS_INIT:

54,000✔

115

      return "init";

54,000✔

123

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

1,454,122,141✔

125

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

1,454,122,141✔

127

  if (keyType == SDB_KEY_BINARY) {

1,454,142,452✔

128

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

466,824,092✔

130

  } else if (keyType == SDB_KEY_INT32) {

987,318,360✔

131

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

941,030,561✔

133

  } else if (keyType == SDB_KEY_INT64) {

46,287,799✔

134

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

46,287,799✔

139

1,454,142,452✔

141

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

1,065,935,522✔

142

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

1,065,935,522✔

147

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

1,065,937,604✔

148

  if (hash == NULL) {

1,065,934,083✔

153

  return hash;

1,065,934,083✔

156

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

465,067,457✔

157

  int32_t  keySize = 0;

465,067,457✔

158

  EKeyType keyType = pSdb->keyTypes[type];

465,067,457✔

160

  if (keyType == SDB_KEY_INT32) {

465,068,012✔

161

    keySize = sizeof(int32_t);

296,561,039✔

162

  } else if (keyType == SDB_KEY_BINARY) {

168,506,973✔

163

    keySize = strlen(pKey) + 1;

167,728,853✔

165

    keySize = sizeof(int64_t);

778,120✔

168

  return keySize;

465,068,012✔

171

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

41,295,627✔

172

  int32_t type = pRow->type;

41,295,627✔

173

  sdbWriteLock(pSdb, type);

41,295,627✔

175

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

41,295,627✔

176

  if (pOldRow != NULL) {

41,295,627✔

183

  pRow->refCount = 0;

41,295,627✔

184

  pRow->status = pRaw->status;

41,295,627✔

185

  sdbPrintOper(pSdb, pRow, "insert");

41,295,627✔

187

  int32_t code = 0;

41,295,627✔

188

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

41,295,627✔

194

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

41,295,627✔

195

  if (insertFp != NULL) {

41,295,627✔

196

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

41,295,627✔

197

    if (code != 0) {

41,295,627✔

208

  sdbUnLock(pSdb, type);

41,295,627✔

210

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

41,295,627✔

211

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

13,047,830✔

213

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

41,295,627✔

214

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

355,961✔

216

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

41,295,627✔

218

  return 0;

41,295,627✔

221

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

62,652,648✔

222

  int32_t type = pNewRow->type;

62,652,648✔

223

  sdbWriteLock(pSdb, type);

62,652,648✔

225

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

62,652,648✔

226

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

62,652,648✔

227

    sdbUnLock(pSdb, type);

39,176,761✔

228

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

39,176,761✔

231

  SSdbRow *pOldRow = *ppOldRow;

23,475,887✔

232

  pOldRow->status = pRaw->status;

23,475,887✔

233

  sdbPrintOper(pSdb, pOldRow, "update");

23,475,887✔

235

  int32_t     code = 0;

23,475,887✔

236

  SdbUpdateFp updateFp = pSdb->updateFps[type];

23,475,887✔

237

  if (updateFp != NULL) {

23,475,887✔

238

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

23,475,887✔

240

  sdbUnLock(pSdb, type);

23,475,887✔

243

  sdbFreeRow(pSdb, pNewRow, false);

23,475,887✔

245

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

23,475,887✔

246

  return code;

23,475,887✔

249

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

12,258,419✔

250

  int32_t type = pRow->type;

12,258,419✔

251

  sdbWriteLock(pSdb, type);

12,258,419✔

253

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

12,258,419✔

254

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

12,258,419✔

255

    sdbUnLock(pSdb, type);

6,312✔

256

    sdbFreeRow(pSdb, pRow, false);

6,312✔

257

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

6,312✔

258

    return terrno;

6,312✔

260

  SSdbRow *pOldRow = *ppOldRow;

12,252,107✔

261

  pOldRow->status = pRaw->status;

12,252,107✔

263

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

12,252,107✔

264

  sdbPrintOper(pSdb, pOldRow, "delete");

12,252,107✔

266

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

12,252,107✔

272

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

12,252,107✔

273

  sdbUnLock(pSdb, type);

12,252,107✔

275

  sdbFreeRow(pSdb, pRow, false);

12,252,107✔

277

  sdbCheckRow(pSdb, pOldRow);

12,252,107✔

278

  return 0;

12,252,107✔

281

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

77,029,933✔

282

  if (pRaw->type == SDB_CFG) {

77,029,933✔

283

    mTrace("sdb write cfg");

24,641,615✔

285

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

77,029,933✔

286

  if (hash == NULL) return terrno;

77,029,933✔

288

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

77,029,933✔

289

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

77,029,933✔

290

  if (pRow == NULL) return terrno;

77,029,933✔

292

  pRow->type = pRaw->type;

77,029,933✔

294

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

77,029,933✔

295

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

77,029,933✔

297

  switch (pRaw->status) {

77,029,933✔

298

    case SDB_STATUS_CREATING:

2,118,866✔

299

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

2,118,866✔

300

      break;

2,118,866✔

301

    case SDB_STATUS_READY:

62,652,648✔

304

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

62,652,648✔

305

      break;

62,652,648✔

306

    case SDB_STATUS_DROPPED:

12,258,419✔

307

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

12,258,419✔

308

      break;

12,258,419✔

311

  return code;

77,029,933✔

314

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

9,484,412✔

315

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

9,484,412✔

316

  sdbFreeRaw(pRaw);

9,484,412✔

317

  return code;

9,484,412✔

320

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

388,034,882✔

321

  terrno = 0;

388,034,882✔

323

  SHashObj *hash = sdbGetHash(pSdb, type);

388,034,006✔

324

  if (hash == NULL) return NULL;

388,033,741✔

326

  void   *pRet = NULL;

388,033,741✔

327

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

388,033,741✔

329

  sdbReadLock(pSdb, type);

388,032,998✔

331

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

388,035,805✔

332

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

388,035,259✔

333

    sdbUnLock(pSdb, type);

87,473,614✔

334

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

87,474,123✔

335

    return NULL;

87,474,123✔

338

  SSdbRow *pRow = *ppRow;

300,561,645✔

339

  switch (pRow->status) {

300,561,645✔

340

    case SDB_STATUS_READY:

300,171,385✔

341

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

300,171,385✔

342

      pRet = pRow->pObj;

300,172,059✔

343

      sdbPrintOper(pSdb, pRow, "acquire");

300,172,059✔

344

      break;

300,171,260✔

345

    case SDB_STATUS_CREATING:

163,023✔

346

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

163,023✔

347

      break;

163,023✔

348

    case SDB_STATUS_DROPPING:

226,950✔

349

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

226,950✔

350

      break;

226,950✔

356

  if (pRet == NULL) {

300,561,233✔

357

    if (!onlyReady) {

389,973✔

365

  sdbUnLock(pSdb, type);

300,561,233✔

366

  return pRet;

300,561,879✔

369

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

387,774,336✔

370

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

261,055✔

371

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

261,055✔

374

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

12,252,107✔

375

  int32_t type = pRow->type;

12,252,107✔

376

  sdbWriteLock(pSdb, type);

12,252,107✔

378

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

12,252,107✔

379

  sdbPrintOper(pSdb, pRow, "check");

12,252,107✔

380

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

12,252,107✔

381

    sdbFreeRow(pSdb, pRow, true);

2,627,940✔

384

  sdbUnLock(pSdb, type);

12,252,107✔

385

12,252,107✔

387

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

624,200,787✔

388

  if (pObj == NULL) return;

624,200,787✔

390

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

616,520,585✔

391

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

616,521,306✔

393

  int32_t type = pRow->type;

616,520,078✔

394

  if (lock) {

616,520,534✔

395

    sdbWriteLock(pSdb, type);

616,177,454✔

398

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

616,520,438✔

399

  sdbPrintOper(pSdb, pRow, "release");

616,527,864✔

400

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

616,525,429✔

401

    sdbFreeRow(pSdb, pRow, true);

9,624,167✔

403

  if (ref < 0) {

616,525,938✔

404

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

919,624✔

407

  if (lock) {

616,523,009✔

408

    sdbUnLock(pSdb, type);

616,179,682✔

412

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

623,857,503✔

414

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

369,292,605✔

415

  *ppObj = NULL;

369,292,605✔

417

  SHashObj *hash = sdbGetHash(pSdb, type);

369,293,479✔

418

  if (hash == NULL) return NULL;

369,292,392✔

420

  sdbReadLock(pSdb, type);

369,292,392✔

422

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

369,293,299✔

423

  while (ppRow != NULL) {

371,835,689✔

424

    SSdbRow *pRow = *ppRow;

258,946,127✔

425

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

258,945,730✔

426

      ppRow = taosHashIterate(hash, ppRow);

2,545,427✔

427

      continue;

2,543,774✔

430

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

256,400,038✔

432

    sdbPrintOper(pSdb, pRow, "fetch");

256,402,182✔

433

    *ppObj = pRow->pObj;

256,400,790✔

434

    break;

256,400,495✔

436

  sdbUnLock(pSdb, type);

369,290,057✔

438

  return ppRow;

369,293,555✔

441

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

75,492,612✔

442

  *ppObj = NULL;

75,492,612✔

444

  SHashObj *hash = sdbGetHash(pSdb, type);

75,492,612✔

445

  if (hash == NULL) return NULL;

75,492,612✔

447

  if (lock) {

75,492,612✔

448

    sdbReadLock(pSdb, type);

74,873,079✔

451

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

75,492,612✔

452

  while (ppRow != NULL) {

75,492,612✔

453

    SSdbRow *pRow = *ppRow;

59,949,132✔

454

    if (pRow == NULL) {

59,949,132✔

459

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

59,949,132✔

460

    sdbPrintOper(pSdb, pRow, "fetch");

59,949,132✔

461

    *ppObj = pRow->pObj;

59,949,132✔

462

    *status = pRow->status;

59,949,132✔

463

    break;

59,949,132✔

465

  if (lock) {

75,492,612✔

466

    sdbUnLock(pSdb, type);

74,873,079✔

469

  return ppRow;

75,492,612✔

472

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

44,346,413✔

473

  if (pIter == NULL) return;

44,346,413✔

474

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

44,328,455✔

475

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

44,328,455✔

476

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

44,328,455✔

477

  if (hash == NULL) return;

44,328,455✔

479

  int32_t type = pRow->type;

44,328,455✔

480

  sdbReadLock(pSdb, type);

44,328,455✔

481

  taosHashCancelIterate(hash, pIter);

44,328,455✔

482

  sdbUnLock(pSdb, type);

44,328,455✔

485

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

14✔

486

  if (pIter == NULL) return;

14✔

487

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

14✔

488

  SHashObj *hash = sdbGetHash(pSdb, type);

14✔

489

  if (hash == NULL) return;

14✔

491

  sdbReadLock(pSdb, type);

14✔

492

  taosHashCancelIterate(hash, pIter);

14✔

493

  sdbUnLock(pSdb, type);

14✔

496

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

5,328,527✔

497

  SHashObj *hash = sdbGetHash(pSdb, type);

5,328,527✔

498

  if (hash == NULL) return;

5,328,527✔

500

  sdbReadLock(pSdb, type);

5,328,527✔

502

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

5,328,527✔

503

  while (ppRow != NULL) {

18,516,721✔

504

    SSdbRow *pRow = *ppRow;

13,188,374✔

505

    if (pRow->status == SDB_STATUS_READY) {

13,188,374✔

506

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

13,188,374✔

507

      if (!isContinue) {

13,188,374✔

508

        taosHashCancelIterate(hash, ppRow);

180✔

509

        break;

180✔

513

    ppRow = taosHashIterate(hash, ppRow);

13,188,194✔

516

  sdbUnLock(pSdb, type);

5,328,527✔

519

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

95,578,622✔

520

  SHashObj *hash = sdbGetHash(pSdb, type);

95,578,622✔

521

  if (hash == NULL) return 0;

95,577,725✔

523

  sdbReadLock(pSdb, type);

95,577,725✔

524

  int32_t size = taosHashGetSize(hash);

95,578,984✔

525

  sdbUnLock(pSdb, type);

95,578,382✔

527

  return size;

95,578,453✔

530

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

10,861,679✔

531

  SHashObj *hash = sdbGetHash(pSdb, type);

10,861,679✔

532

  if (hash == NULL) return -1;

10,861,679✔

534

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

10,861,679✔

536

  int32_t maxId = 0;

10,861,679✔

537

  sdbReadLock(pSdb, type);

10,861,679✔

539

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

10,861,679✔

540

  while (ppRow != NULL) {

16,343,369✔

541

    SSdbRow *pRow = *ppRow;

5,481,690✔

542

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

5,481,690✔

543

    maxId = TMAX(id, maxId);

5,481,690✔

544

    ppRow = taosHashIterate(hash, ppRow);

5,481,690✔

547

  sdbUnLock(pSdb, type);

10,861,679✔

548

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

10,861,679✔

549

  return maxId + 1;

10,861,679✔

552

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

60,950,926✔

553

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

60,950,926✔

558

  return pSdb->tableVer[type];

60,950,926✔

574

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

3,490✔

575

  SHashObj *hash = sdbGetHash(pSdb, type);

3,490✔

576

  if (hash == NULL) return false;

3,490✔

577

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

3,490✔

579

  sdbReadLock(pSdb, type);

3,490✔

580

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

3,490✔

581

  sdbUnLock(pSdb, type);

3,490✔

583

  return (NULL != p);

3,490✔

taosdata / TDengine / #4881

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) {	196,699,770✔
22	switch (type) {	196,699,770✔
23	case SDB_TRANS:	31,044,329✔
24	return "trans";	31,044,329✔
25	case SDB_CLUSTER:	1,779,934✔
26	return "cluster";	1,779,934✔
27	case SDB_MNODE:	1,862,110✔
28	return "mnode";	1,862,110✔
29	case SDB_QNODE:	979,464✔
30	return "qnode";	979,464✔
31	case SDB_SNODE:	982,440✔
32	return "snode";	982,440✔
33	case SDB_DNODE:	3,396,804✔
34	return "dnode";	3,396,804✔
35	case SDB_USER:	3,716,081✔
36	return "user";	3,716,081✔
37	case SDB_AUTH:	102✔
38	return "auth";	102✔
39	case SDB_ACCT:	1,703,062✔
40	return "acct";	1,703,062✔
41	case SDB_STREAM_CK:	102✔
42	return "stream_ck";	102✔
43	case SDB_STREAM:	987,799✔
44	return "stream";	987,799✔
45	case SDB_OFFSET:	102✔
46	return "offset";	102✔
47	case SDB_SUBSCRIBE:	1,045,663✔
48	return "subscribe";	1,045,663✔
49	case SDB_CONSUMER:	1,131,517✔
50	return "consumer";	1,131,517✔
51	case SDB_TOPIC:	1,022,455✔
52	return "topic";	1,022,455✔
53	case SDB_VGROUP:	16,040,201✔
54	return "vgroup";	16,040,201✔
55	case SDB_SMA:	967,765✔
56	return "sma";	967,765✔
57	case SDB_STB:	28,587,616✔
58	return "stb";	28,587,616✔
59	case SDB_DB:	9,774,759✔
60	return "db";	9,774,759✔
61	case SDB_FUNC:	1,009,337✔
62	return "func";	1,009,337✔
63	case SDB_IDX:	5,425,795✔
64	return "idx";	5,425,795✔
65	case SDB_VIEW:	1,559,146✔
66	return "view";	1,559,146✔
67	case SDB_STREAM_SEQ:	102✔
68	return "stream_seq";	102✔
69	case SDB_COMPACT:	1,114,549✔
70	return "compact";	1,114,549✔
71	case SDB_COMPACT_DETAIL:	1,516,087✔
72	return "compact_detail";	1,516,087✔
73	case SDB_GRANT:	2,026,501✔
74	return "grant";	2,026,501✔
75	case SDB_ARBGROUP:	1,021,395✔
76	return "arb_group";	1,021,395✔
77	case SDB_ANODE:	967,765✔
78	return "anode";	967,765✔
79	case SDB_BNODE:	1,203,792✔
80	return "bnode";	1,203,792✔
81	case SDB_CFG:	62,637,491✔
82	return "config";	62,637,491✔
83	case SDB_MOUNT:	972,112✔
84	return "mount";	972,112✔
85	case SDB_MOUNT_LOG:	970,267✔
86	return "mount_log";	970,267✔
87	case SDB_SSMIGRATE:	967,765✔
88	return "ssmigrate";	967,765✔
89	case SDB_SCAN:	968,251✔
90	return "scan";	968,251✔
91	case SDB_SCAN_DETAIL:	968,476✔
92	return "scan_detail";	968,476✔
93	case SDB_RSMA:	1,070,014✔
94	return "rsma";	1,070,014✔
95	case SDB_INSTANCE:	540,860✔
96	return "instance";	540,860✔
97	case SDB_ENCRYPT_ALGORITHMS:	4,593,139✔
98	return "encrypt_algr";	4,593,139✔
99	default:	2,144,621✔
100	return "undefine";	2,144,621✔
101	}
102	}
103
104	const char *sdbStatusName(ESdbStatus status) {	82,998,038✔
105	switch (status) {	82,998,038✔
106	case SDB_STATUS_CREATING:	4,202,453✔
107	return "creating";	4,202,453✔
108	case SDB_STATUS_DROPPING:	1,488,696✔
109	return "dropping";	1,488,696✔
110	case SDB_STATUS_READY:	69,405,212✔
111	return "ready";	69,405,212✔
112	case SDB_STATUS_DROPPED:	7,847,677✔
113	return "dropped";	7,847,677✔
114	case SDB_STATUS_INIT:	54,000✔
115	return "init";	54,000✔
116	case SDB_STATUS_UPDATE:	×
117	return "update";	×
118	default:	×
119	return "undefine";	×
120	}
121	}
122
123	void sdbPrintOper(SSdb pSdb, SSdbRow pRow, const char *oper) {	1,454,122,141✔
124	#if 1
125	EKeyType keyType = pSdb->keyTypes[pRow->type];	1,454,122,141✔
126
127	if (keyType == SDB_KEY_BINARY) {	1,454,142,452✔
128	mTrace("%s:%s, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj,	466,824,092✔
129	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
130	} else if (keyType == SDB_KEY_INT32) {	987,318,360✔
131	mTrace("%s:%d, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (int32_t )pRow->pObj,	941,030,561✔
132	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
133	} else if (keyType == SDB_KEY_INT64) {	46,287,799✔
134	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	46,287,799✔
135	(int64_t )pRow->pObj, pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
136	} else {
137	}
138	#endif
139	}	1,454,142,452✔
140
141	static SHashObj sdbGetHash(SSdb pSdb, int32_t type) {	1,065,935,522✔
142	if (type >= SDB_MAX \|\| type < 0) {	1,065,935,522✔
143	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
144	return NULL;	×
145	}
146
147	SHashObj *hash = pSdb->hashObjs[type];	1,065,937,604✔
148	if (hash == NULL) {	1,065,934,083✔
149	terrno = TSDB_CODE_APP_ERROR;	×
150	return NULL;	×
151	}
152
153	return hash;	1,065,934,083✔
154	}
155
156	static int32_t sdbGetkeySize(SSdb pSdb, ESdbType type, const void pKey) {	465,067,457✔
157	int32_t keySize = 0;	465,067,457✔
158	EKeyType keyType = pSdb->keyTypes[type];	465,067,457✔
159
160	if (keyType == SDB_KEY_INT32) {	465,068,012✔
161	keySize = sizeof(int32_t);	296,561,039✔
162	} else if (keyType == SDB_KEY_BINARY) {	168,506,973✔
163	keySize = strlen(pKey) + 1;	167,728,853✔
164	} else {
165	keySize = sizeof(int64_t);	778,120✔
166	}
167
168	return keySize;	465,068,012✔
169	}
170
171	static int32_t sdbInsertRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	41,295,627✔
172	int32_t type = pRow->type;	41,295,627✔
173	sdbWriteLock(pSdb, type);	41,295,627✔
174
175	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	41,295,627✔
176	if (pOldRow != NULL) {	41,295,627✔
177	sdbUnLock(pSdb, type);	×
178	sdbFreeRow(pSdb, pRow, false);	×
179	terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;	×
180	return terrno;	×
181	}
182
183	pRow->refCount = 0;	41,295,627✔
184	pRow->status = pRaw->status;	41,295,627✔
185	sdbPrintOper(pSdb, pRow, "insert");	41,295,627✔
186
187	int32_t code = 0;	41,295,627✔
188	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	41,295,627✔
189	sdbUnLock(pSdb, type);	×
190	sdbFreeRow(pSdb, pRow, false);	×
191	return code;	×
192	}
193
194	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	41,295,627✔
195	if (insertFp != NULL) {	41,295,627✔
196	code = (*insertFp)(pSdb, pRow->pObj);	41,295,627✔
197	if (code != 0) {	41,295,627✔
198	if (taosHashRemove(hash, pRow->pObj, keySize) != 0) {	×
199	mError("failed to remove row from hash");	×
200	}
201	sdbFreeRow(pSdb, pRow, false);	×
202	sdbUnLock(pSdb, type);	×
203	terrno = code;	×
204	return terrno;	×
205	}
206	}
207
208	sdbUnLock(pSdb, type);	41,295,627✔
209
210	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	41,295,627✔
211	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	13,047,830✔
212	}
213	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	41,295,627✔
214	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	355,961✔
215	}
216	pSdb->tableVer[pRow->type]++;	41,295,627✔
217
218	return 0;	41,295,627✔
219	}
220
221	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	62,652,648✔
222	int32_t type = pNewRow->type;	62,652,648✔
223	sdbWriteLock(pSdb, type);	62,652,648✔
224
225	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	62,652,648✔
226	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	62,652,648✔
227	sdbUnLock(pSdb, type);	39,176,761✔
228	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	39,176,761✔
229	}
230
231	SSdbRow pOldRow = ppOldRow;	23,475,887✔
232	pOldRow->status = pRaw->status;	23,475,887✔
233	sdbPrintOper(pSdb, pOldRow, "update");	23,475,887✔
234
235	int32_t code = 0;	23,475,887✔
236	SdbUpdateFp updateFp = pSdb->updateFps[type];	23,475,887✔
237	if (updateFp != NULL) {	23,475,887✔
238	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	23,475,887✔
239	}
240	sdbUnLock(pSdb, type);	23,475,887✔
241
242	// sdbUnLock(pSdb, type);
243	sdbFreeRow(pSdb, pNewRow, false);	23,475,887✔
244
245	pSdb->tableVer[pOldRow->type]++;	23,475,887✔
246	return code;	23,475,887✔
247	}
248
249	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	12,258,419✔
250	int32_t type = pRow->type;	12,258,419✔
251	sdbWriteLock(pSdb, type);	12,258,419✔
252
253	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	12,258,419✔
254	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	12,258,419✔
255	sdbUnLock(pSdb, type);	6,312✔
256	sdbFreeRow(pSdb, pRow, false);	6,312✔
257	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	6,312✔
258	return terrno;	6,312✔
259	}
260	SSdbRow pOldRow = ppOldRow;	12,252,107✔
261	pOldRow->status = pRaw->status;	12,252,107✔
262
263	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	12,252,107✔
264	sdbPrintOper(pSdb, pOldRow, "delete");	12,252,107✔
265
266	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	12,252,107✔
267	sdbUnLock(pSdb, type);	×
268	sdbFreeRow(pSdb, pRow, false);	×
269	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	×
270	return terrno;	×
271	}
272	pSdb->tableVer[pOldRow->type]++;	12,252,107✔
273	sdbUnLock(pSdb, type);	12,252,107✔
274
275	sdbFreeRow(pSdb, pRow, false);	12,252,107✔
276
277	sdbCheckRow(pSdb, pOldRow);	12,252,107✔
278	return 0;	12,252,107✔
279	}
280
281	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	77,029,933✔
282	if (pRaw->type == SDB_CFG) {	77,029,933✔
283	mTrace("sdb write cfg");	24,641,615✔
284	}
285	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	77,029,933✔
286	if (hash == NULL) return terrno;	77,029,933✔
287
288	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	77,029,933✔
289	SSdbRow pRow = (decodeFp)(pRaw);	77,029,933✔
290	if (pRow == NULL) return terrno;	77,029,933✔
291
292	pRow->type = pRaw->type;	77,029,933✔
293
294	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	77,029,933✔
295	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	77,029,933✔
296
297	switch (pRaw->status) {	77,029,933✔
298	case SDB_STATUS_CREATING:	2,118,866✔
299	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	2,118,866✔
300	break;	2,118,866✔
301	case SDB_STATUS_READY:	62,652,648✔
302	case SDB_STATUS_UPDATE:
303	case SDB_STATUS_DROPPING:
304	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	62,652,648✔
305	break;	62,652,648✔
306	case SDB_STATUS_DROPPED:	12,258,419✔
307	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	12,258,419✔
308	break;	12,258,419✔
309	}
310
311	return code;	77,029,933✔
312	}
313
314	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	9,484,412✔
315	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	9,484,412✔
316	sdbFreeRaw(pRaw);	9,484,412✔
317	return code;	9,484,412✔
318	}
319
320	void sdbAcquireAll(SSdb pSdb, ESdbType type, const void *pKey, bool onlyReady) {	388,034,882✔
321	terrno = 0;	388,034,882✔
322
323	SHashObj *hash = sdbGetHash(pSdb, type);	388,034,006✔
324	if (hash == NULL) return NULL;	388,033,741✔
325
326	void *pRet = NULL;	388,033,741✔
327	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	388,033,741✔
328
329	sdbReadLock(pSdb, type);	388,032,998✔
330
331	SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);	388,035,805✔
332	if (ppRow == NULL \|\| *ppRow == NULL) {	388,035,259✔
333	sdbUnLock(pSdb, type);	87,473,614✔
334	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	87,474,123✔
335	return NULL;	87,474,123✔
336	}
337
338	SSdbRow pRow = ppRow;	300,561,645✔
339	switch (pRow->status) {	300,561,645✔
340	case SDB_STATUS_READY:	300,171,385✔
341	(void)atomic_add_fetch_32(&pRow->refCount, 1);	300,171,385✔
342	pRet = pRow->pObj;	300,172,059✔
343	sdbPrintOper(pSdb, pRow, "acquire");	300,172,059✔
344	break;	300,171,260✔
345	case SDB_STATUS_CREATING:	163,023✔
346	terrno = TSDB_CODE_SDB_OBJ_CREATING;	163,023✔
347	break;	163,023✔
348	case SDB_STATUS_DROPPING:	226,950✔
349	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	226,950✔
350	break;	226,950✔
351	default:	×
352	terrno = TSDB_CODE_APP_ERROR;	×
353	break;	×
354	}
355
356	if (pRet == NULL) {	300,561,233✔
357	if (!onlyReady) {	389,973✔
358	terrno = 0;	×
359	(void)atomic_add_fetch_32(&pRow->refCount, 1);	×
360	pRet = pRow->pObj;	×
361	sdbPrintOper(pSdb, pRow, "acquire");	×
362	}
363	}
364
365	sdbUnLock(pSdb, type);	300,561,233✔
366	return pRet;	300,561,879✔
367	}
368
369	void sdbAcquire(SSdb pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }	387,774,336✔
370	void sdbAcquireNotReadyObj(SSdb pSdb, ESdbType type, const void *pKey) {	261,055✔
371	return sdbAcquireAll(pSdb, type, pKey, false);	261,055✔
372	}
373
374	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	12,252,107✔
375	int32_t type = pRow->type;	12,252,107✔
376	sdbWriteLock(pSdb, type);	12,252,107✔
377
378	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	12,252,107✔
379	sdbPrintOper(pSdb, pRow, "check");	12,252,107✔
380	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	12,252,107✔
381	sdbFreeRow(pSdb, pRow, true);	2,627,940✔
382	}
383
384	sdbUnLock(pSdb, type);	12,252,107✔
385	}	12,252,107✔
386
387	void sdbReleaseLock(SSdb pSdb, void pObj, bool lock) {	624,200,787✔
388	if (pObj == NULL) return;	624,200,787✔
389
390	SSdbRow pRow = (SSdbRow )((char *)pObj - sizeof(SSdbRow));	616,520,585✔
391	if (pRow->type >= SDB_MAX) return;	616,521,306✔
392
393	int32_t type = pRow->type;	616,520,078✔
394	if (lock) {	616,520,534✔
395	sdbWriteLock(pSdb, type);	616,177,454✔
396	}
397
398	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	616,520,438✔
399	sdbPrintOper(pSdb, pRow, "release");	616,527,864✔
400	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	616,525,429✔
401	sdbFreeRow(pSdb, pRow, true);	9,624,167✔
402	}
403	if (ref < 0) {	616,525,938✔
404	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	919,624✔
405	}
406
407	if (lock) {	616,523,009✔
408	sdbUnLock(pSdb, type);	616,179,682✔
409	}
410	}
411
412	void sdbRelease(SSdb pSdb, void pObj) { sdbReleaseLock(pSdb, pObj, true); }	623,857,503✔
413
414	void sdbFetch(SSdb pSdb, ESdbType type, void pIter, void *ppObj) {	369,292,605✔
415	*ppObj = NULL;	369,292,605✔
416
417	SHashObj *hash = sdbGetHash(pSdb, type);	369,293,479✔
418	if (hash == NULL) return NULL;	369,292,392✔
419
420	sdbReadLock(pSdb, type);	369,292,392✔
421
422	SSdbRow **ppRow = taosHashIterate(hash, pIter);	369,293,299✔
423	while (ppRow != NULL) {	371,835,689✔
424	SSdbRow pRow = ppRow;	258,946,127✔
425	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	258,945,730✔
426	ppRow = taosHashIterate(hash, ppRow);	2,545,427✔
427	continue;	2,543,774✔
428	}
429
430	(void) atomic_add_fetch_32(&pRow->refCount, 1);	256,400,038✔
431
432	sdbPrintOper(pSdb, pRow, "fetch");	256,402,182✔
433	*ppObj = pRow->pObj;	256,400,790✔
434	break;	256,400,495✔
435	}
436	sdbUnLock(pSdb, type);	369,290,057✔
437
438	return ppRow;	369,293,555✔
439	}
440
441	void sdbFetchAll(SSdb pSdb, ESdbType type, void pIter, void ppObj, ESdbStatus status, bool lock) {	75,492,612✔
442	*ppObj = NULL;	75,492,612✔
443
444	SHashObj *hash = sdbGetHash(pSdb, type);	75,492,612✔
445	if (hash == NULL) return NULL;	75,492,612✔
446
447	if (lock) {	75,492,612✔
448	sdbReadLock(pSdb, type);	74,873,079✔
449	}
450
451	SSdbRow **ppRow = taosHashIterate(hash, pIter);	75,492,612✔
452	while (ppRow != NULL) {	75,492,612✔
453	SSdbRow pRow = ppRow;	59,949,132✔
454	if (pRow == NULL) {	59,949,132✔
455	ppRow = taosHashIterate(hash, ppRow);	×
456	continue;	×
457	}
458
459	(void)atomic_add_fetch_32(&pRow->refCount, 1);	59,949,132✔
460	sdbPrintOper(pSdb, pRow, "fetch");	59,949,132✔
461	*ppObj = pRow->pObj;	59,949,132✔
462	*status = pRow->status;	59,949,132✔
463	break;	59,949,132✔
464	}
465	if (lock) {	75,492,612✔
466	sdbUnLock(pSdb, type);	74,873,079✔
467	}
468
469	return ppRow;	75,492,612✔
470	}
471
472	void sdbCancelFetch(SSdb pSdb, void pIter) {	44,346,413✔
473	if (pIter == NULL) return;	44,346,413✔
474	SSdbRow pRow = (SSdbRow **)pIter;	44,328,455✔
475	mTrace("cancel fetch row:%p", pRow);	44,328,455✔
476	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	44,328,455✔
477	if (hash == NULL) return;	44,328,455✔
478
479	int32_t type = pRow->type;	44,328,455✔
480	sdbReadLock(pSdb, type);	44,328,455✔
481	taosHashCancelIterate(hash, pIter);	44,328,455✔
482	sdbUnLock(pSdb, type);	44,328,455✔
483	}
484
485	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	14✔
486	if (pIter == NULL) return;	14✔
487	if (type >= SDB_MAX \|\| type < 0) return;	14✔
488	SHashObj *hash = sdbGetHash(pSdb, type);	14✔
489	if (hash == NULL) return;	14✔
490
491	sdbReadLock(pSdb, type);	14✔
492	taosHashCancelIterate(hash, pIter);	14✔
493	sdbUnLock(pSdb, type);	14✔
494	}
495
496	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	5,328,527✔
497	SHashObj *hash = sdbGetHash(pSdb, type);	5,328,527✔
498	if (hash == NULL) return;	5,328,527✔
499
500	sdbReadLock(pSdb, type);	5,328,527✔
501
502	SSdbRow **ppRow = taosHashIterate(hash, NULL);	5,328,527✔
503	while (ppRow != NULL) {	18,516,721✔
504	SSdbRow pRow = ppRow;	13,188,374✔
505	if (pRow->status == SDB_STATUS_READY) {	13,188,374✔
506	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	13,188,374✔
507	if (!isContinue) {	13,188,374✔
508	taosHashCancelIterate(hash, ppRow);	180✔
509	break;	180✔
510	}
511	}
512
513	ppRow = taosHashIterate(hash, ppRow);	13,188,194✔
514	}
515
516	sdbUnLock(pSdb, type);	5,328,527✔
517	}
518
519	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	95,578,622✔
520	SHashObj *hash = sdbGetHash(pSdb, type);	95,578,622✔
521	if (hash == NULL) return 0;	95,577,725✔
522
523	sdbReadLock(pSdb, type);	95,577,725✔
524	int32_t size = taosHashGetSize(hash);	95,578,984✔
525	sdbUnLock(pSdb, type);	95,578,382✔
526
527	return size;	95,578,453✔
528	}
529
530	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	10,861,679✔
531	SHashObj *hash = sdbGetHash(pSdb, type);	10,861,679✔
532	if (hash == NULL) return -1;	10,861,679✔
533
534	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	10,861,679✔
535
536	int32_t maxId = 0;	10,861,679✔
537	sdbReadLock(pSdb, type);	10,861,679✔
538
539	SSdbRow **ppRow = taosHashIterate(hash, NULL);	10,861,679✔
540	while (ppRow != NULL) {	16,343,369✔
541	SSdbRow pRow = ppRow;	5,481,690✔
542	int32_t id = (int32_t )pRow->pObj;	5,481,690✔
543	maxId = TMAX(id, maxId);	5,481,690✔
544	ppRow = taosHashIterate(hash, ppRow);	5,481,690✔
545	}
546
547	sdbUnLock(pSdb, type);	10,861,679✔
548	maxId = TMAX(maxId, pSdb->maxId[type]);	10,861,679✔
549	return maxId + 1;	10,861,679✔
550	}
551
552	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	60,950,926✔
553	if (type >= SDB_MAX \|\| type < 0) {	60,950,926✔
554	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
555	return -1;	×
556	}
557
558	return pSdb->tableVer[type];	60,950,926✔
559	}
560
561	bool countValid(SMnode pMnode, void pObj, void p1, void p2, void *p3) {	×
562	int32_t *pInt = p1;	×
563	(*pInt) += 1;	×
564	return true;	×
565	}
566
567	int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {	×
568	int32_t num = 0;	×
569	sdbTraverse(pSdb, type, countValid, &num, 0, 0);	×
570	return num;	×
571	}
572
573
574	bool sdbCheckExists(SSdb pSdb, ESdbType type, const void pKey) {	3,490✔
575	SHashObj *hash = sdbGetHash(pSdb, type);	3,490✔
576	if (hash == NULL) return false;	3,490✔
577	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	3,490✔
578
579	sdbReadLock(pSdb, type);	3,490✔
580	void* p = taosHashGet(hash, pKey, keySize);	3,490✔
581	sdbUnLock(pSdb, type);	3,490✔
582
583	return (NULL != p);	3,490✔
584	}
585
586

taosdata / TDengine / #4881

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