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

21

const char *sdbTableName(ESdbType type) {

384,487,345✔

22

  switch (type) {

384,487,345✔

23

    case SDB_TRANS:

61,228,718✔

24

      return "trans";

61,228,718✔

25

    case SDB_CLUSTER:

3,697,509✔

26

      return "cluster";

3,697,509✔

27

    case SDB_MNODE:

4,165,961✔

28

      return "mnode";

4,165,961✔

29

    case SDB_QNODE:

2,177,620✔

30

      return "qnode";

2,177,620✔

31

    case SDB_SNODE:

4,063,083✔

32

      return "snode";

4,063,083✔

33

    case SDB_DNODE:

7,866,664✔

34

      return "dnode";

7,866,664✔

35

    case SDB_USER:

7,815,576✔

36

      return "user";

7,815,576✔

37

    case SDB_AUTH:

1,530✔

38

      return "auth";

1,530✔

39

    case SDB_ACCT:

3,509,355✔

40

      return "acct";

3,509,355✔

41

    case SDB_STREAM_CK:

1,530✔

42

      return "stream_ck";

1,530✔

43

    case SDB_STREAM:

2,743,752✔

44

      return "stream";

2,743,752✔

45

    case SDB_OFFSET:

1,530✔

46

      return "offset";

1,530✔

47

    case SDB_SUBSCRIBE:

2,359,551✔

48

      return "subscribe";

2,359,551✔

49

    case SDB_CONSUMER:

2,692,158✔

50

      return "consumer";

2,692,158✔

51

    case SDB_TOPIC:

2,272,648✔

52

      return "topic";

2,272,648✔

53

    case SDB_VGROUP:

30,064,507✔

54

      return "vgroup";

30,064,507✔

55

    case SDB_SMA:

2,035,424✔

56

      return "sma";

2,035,424✔

57

    case SDB_STB:

50,251,241✔

58

      return "stb";

50,251,241✔

59

    case SDB_DB:

17,818,286✔

60

      return "db";

17,818,286✔

61

    case SDB_FUNC:

2,162,881✔

62

      return "func";

2,162,881✔

63

    case SDB_IDX:

12,978,908✔

64

      return "idx";

12,978,908✔

65

    case SDB_VIEW:

3,251,225✔

66

      return "view";

3,251,225✔

67

    case SDB_STREAM_SEQ:

1,530✔

68

      return "stream_seq";

1,530✔

69

    case SDB_COMPACT:

2,262,632✔

70

      return "compact";

2,262,632✔

71

    case SDB_COMPACT_DETAIL:

3,026,918✔

72

      return "compact_detail";

3,026,918✔

73

    case SDB_GRANT:

4,177,729✔

74

      return "grant";

4,177,729✔

75

    case SDB_ARBGROUP:

2,117,635✔

76

      return "arb_group";

2,117,635✔

77

    case SDB_ANODE:

2,035,424✔

78

      return "anode";

2,035,424✔

79

    case SDB_BNODE:

2,497,386✔

80

      return "bnode";

2,497,386✔

81

    case SDB_CFG:

126,874,454✔

82

      return "config";

126,874,454✔

83

    case SDB_MOUNT:

2,043,698✔

84

      return "mount";

2,043,698✔

85

    case SDB_MOUNT_LOG:

2,040,194✔

86

      return "mount_log";

2,040,194✔

87

    case SDB_SSMIGRATE:

2,035,424✔

88

      return "ssmigrate";

2,035,424✔

89

    case SDB_SCAN:

2,038,784✔

90

      return "scan";

2,038,784✔

91

    case SDB_SCAN_DETAIL:

2,040,464✔

92

      return "scan_detail";

2,040,464✔

93

    case SDB_RSMA:

2,325,728✔

94

      return "rsma";

2,325,728✔

95

    case SDB_INSTANCE:

1,188,157✔

96

      return "instance";

1,188,157✔

97

    default:

4,621,531✔

98

      return "undefine";

4,621,531✔

102

const char *sdbStatusName(ESdbStatus status) {

156,553,053✔

103

  switch (status) {

156,553,053✔

104

    case SDB_STATUS_CREATING:

8,324,899✔

105

      return "creating";

8,324,899✔

106

    case SDB_STATUS_DROPPING:

2,703,572✔

107

      return "dropping";

2,703,572✔

108

    case SDB_STATUS_READY:

131,205,138✔

109

      return "ready";

131,205,138✔

110

    case SDB_STATUS_DROPPED:

14,233,904✔

111

      return "dropped";

14,233,904✔

112

    case SDB_STATUS_INIT:

85,540✔

113

      return "init";

85,540✔

121

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

2,147,483,647✔

123

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

2,147,483,647✔

125

  if (keyType == SDB_KEY_BINARY) {

2,147,483,647✔

126

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

1,067,931,288✔

128

  } else if (keyType == SDB_KEY_INT32) {

2,147,483,647✔

129

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

2,119,240,872✔

131

  } else if (keyType == SDB_KEY_INT64) {

104,626,323✔

132

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

104,626,323✔

137

2,147,483,647✔

139

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

2,147,483,647✔

140

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

2,147,483,647✔

145

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

2,147,483,647✔

146

  if (hash == NULL) {

2,147,483,647✔

151

  return hash;

2,147,483,647✔

154

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

981,188,878✔

155

  int32_t  keySize = 0;

981,188,878✔

156

  EKeyType keyType = pSdb->keyTypes[type];

981,188,878✔

158

  if (keyType == SDB_KEY_INT32) {

981,189,100✔

159

    keySize = sizeof(int32_t);

642,715,045✔

160

  } else if (keyType == SDB_KEY_BINARY) {

338,474,055✔

161

    keySize = strlen(pKey) + 1;

335,743,885✔

163

    keySize = sizeof(int64_t);

2,730,170✔

166

  return keySize;

981,189,100✔

169

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

86,790,332✔

170

  int32_t type = pRow->type;

86,790,332✔

171

  sdbWriteLock(pSdb, type);

86,790,332✔

173

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

86,790,332✔

174

  if (pOldRow != NULL) {

86,790,332✔

181

  pRow->refCount = 0;

86,790,332✔

182

  pRow->status = pRaw->status;

86,790,332✔

183

  sdbPrintOper(pSdb, pRow, "insert");

86,790,332✔

185

  int32_t code = 0;

86,790,332✔

186

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

86,790,332✔

192

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

86,790,332✔

193

  if (insertFp != NULL) {

86,790,332✔

194

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

86,790,332✔

195

    if (code != 0) {

86,790,332✔

206

  sdbUnLock(pSdb, type);

86,790,332✔

208

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

86,790,332✔

209

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

23,727,539✔

211

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

86,790,332✔

212

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

767,726✔

214

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

86,790,332✔

216

  return 0;

86,790,332✔

219

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

126,674,882✔

220

  int32_t type = pNewRow->type;

126,674,882✔

221

  sdbWriteLock(pSdb, type);

126,674,882✔

223

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

126,674,882✔

224

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

126,674,882✔

225

    sdbUnLock(pSdb, type);

82,485,090✔

226

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

82,485,090✔

229

  SSdbRow *pOldRow = *ppOldRow;

44,189,792✔

230

  pOldRow->status = pRaw->status;

44,189,792✔

231

  sdbPrintOper(pSdb, pOldRow, "update");

44,189,792✔

233

  int32_t     code = 0;

44,189,792✔

234

  SdbUpdateFp updateFp = pSdb->updateFps[type];

44,189,792✔

235

  if (updateFp != NULL) {

44,189,792✔

236

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

44,189,792✔

238

  sdbUnLock(pSdb, type);

44,189,792✔

241

  sdbFreeRow(pSdb, pNewRow, false);

44,189,792✔

243

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

44,189,792✔

244

  return code;

44,189,792✔

247

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

23,498,956✔

248

  int32_t type = pRow->type;

23,498,956✔

249

  sdbWriteLock(pSdb, type);

23,498,956✔

251

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

23,498,956✔

252

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

23,498,956✔

253

    sdbUnLock(pSdb, type);

9,793✔

254

    sdbFreeRow(pSdb, pRow, false);

9,793✔

255

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

9,793✔

256

    return terrno;

9,793✔

258

  SSdbRow *pOldRow = *ppOldRow;

23,489,163✔

259

  pOldRow->status = pRaw->status;

23,489,163✔

261

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

23,489,163✔

262

  sdbPrintOper(pSdb, pOldRow, "delete");

23,489,163✔

264

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

23,489,163✔

270

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

23,489,163✔

271

  sdbUnLock(pSdb, type);

23,489,163✔

273

  sdbFreeRow(pSdb, pRow, false);

23,489,163✔

275

  sdbCheckRow(pSdb, pOldRow);

23,489,163✔

276

  return 0;

23,489,163✔

279

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

154,479,080✔

280

  if (pRaw->type == SDB_CFG) {

154,479,080✔

281

    mTrace("sdb write cfg");

52,279,135✔

283

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

154,479,080✔

284

  if (hash == NULL) return terrno;

154,479,080✔

286

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

154,479,080✔

287

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

154,479,080✔

288

  if (pRow == NULL) return terrno;

154,479,080✔

290

  pRow->type = pRaw->type;

154,479,080✔

292

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

154,479,080✔

293

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

154,479,080✔

295

  switch (pRaw->status) {

154,479,080✔

296

    case SDB_STATUS_CREATING:

4,305,242✔

297

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

4,305,242✔

298

      break;

4,305,242✔

299

    case SDB_STATUS_READY:

126,674,882✔

302

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

126,674,882✔

303

      break;

126,674,882✔

304

    case SDB_STATUS_DROPPED:

23,498,956✔

305

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

23,498,956✔

306

      break;

23,498,956✔

309

  return code;

154,479,080✔

312

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

18,524,725✔

313

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

18,524,725✔

314

  sdbFreeRaw(pRaw);

18,524,725✔

315

  return code;

18,524,725✔

318

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

826,252,585✔

319

  terrno = 0;

826,252,585✔

321

  SHashObj *hash = sdbGetHash(pSdb, type);

826,252,561✔

322

  if (hash == NULL) return NULL;

826,250,995✔

324

  void   *pRet = NULL;

826,250,995✔

325

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

826,250,995✔

327

  sdbReadLock(pSdb, type);

826,250,896✔

329

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

826,253,578✔

330

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

826,253,112✔

331

    sdbUnLock(pSdb, type);

183,677,769✔

332

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

183,677,130✔

333

    return NULL;

183,677,130✔

336

  SSdbRow *pRow = *ppRow;

642,575,590✔

337

  switch (pRow->status) {

642,575,907✔

338

    case SDB_STATUS_READY:

640,359,991✔

339

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

640,359,991✔

340

      pRet = pRow->pObj;

640,361,964✔

341

      sdbPrintOper(pSdb, pRow, "acquire");

640,362,159✔

342

      break;

640,360,675✔

343

    case SDB_STATUS_CREATING:

1,773,047✔

344

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

1,773,047✔

345

      break;

1,773,047✔

346

    case SDB_STATUS_DROPPING:

442,259✔

347

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

442,259✔

348

      break;

442,259✔

354

  if (pRet == NULL) {

642,575,981✔

355

    if (!onlyReady) {

2,215,306✔

363

  sdbUnLock(pSdb, type);

642,575,981✔

364

  return pRet;

642,576,597✔

367

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

825,582,598✔

368

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

670,304✔

369

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

670,304✔

372

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

23,489,163✔

373

  int32_t type = pRow->type;

23,489,163✔

374

  sdbWriteLock(pSdb, type);

23,489,163✔

376

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

23,489,163✔

377

  sdbPrintOper(pSdb, pRow, "check");

23,489,163✔

378

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

23,489,163✔

379

    sdbFreeRow(pSdb, pRow, true);

4,649,938✔

382

  sdbUnLock(pSdb, type);

23,489,163✔

383

23,489,163✔

385

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

1,439,261,159✔

386

  if (pObj == NULL) return;

1,439,261,159✔

388

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

1,422,935,730✔

389

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

1,422,936,505✔

391

  int32_t type = pRow->type;

1,422,932,455✔

392

  if (lock) {

1,422,935,691✔

393

    sdbWriteLock(pSdb, type);

1,421,815,215✔

396

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

1,422,937,877✔

397

  sdbPrintOper(pSdb, pRow, "release");

1,422,943,730✔

398

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

1,422,937,790✔

399

    sdbFreeRow(pSdb, pRow, true);

18,839,225✔

401

  if (ref < 0) {

1,422,936,979✔

402

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

1,437,949✔

405

  if (lock) {

1,422,938,257✔

406

    sdbUnLock(pSdb, type);

1,421,818,996✔

410

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

1,438,142,258✔

412

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

877,172,365✔

413

  *ppObj = NULL;

877,172,365✔

415

  SHashObj *hash = sdbGetHash(pSdb, type);

877,173,384✔

416

  if (hash == NULL) return NULL;

877,167,366✔

418

  sdbReadLock(pSdb, type);

877,167,366✔

420

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

877,170,835✔

421

  while (ppRow != NULL) {

886,167,051✔

422

    SSdbRow *pRow = *ppRow;

650,829,840✔

423

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

650,830,445✔

424

      ppRow = taosHashIterate(hash, ppRow);

9,000,679✔

425

      continue;

8,996,250✔

428

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

641,829,580✔

430

    sdbPrintOper(pSdb, pRow, "fetch");

641,833,424✔

431

    *ppObj = pRow->pObj;

641,825,965✔

432

    break;

641,830,529✔

434

  sdbUnLock(pSdb, type);

877,167,740✔

436

  return ppRow;

877,168,457✔

439

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

175,067,196✔

440

  *ppObj = NULL;

175,067,196✔

442

  SHashObj *hash = sdbGetHash(pSdb, type);

175,067,196✔

443

  if (hash == NULL) return NULL;

175,067,196✔

445

  if (lock) {

175,067,196✔

446

    sdbReadLock(pSdb, type);

173,189,791✔

449

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

175,067,196✔

450

  while (ppRow != NULL) {

175,067,196✔

451

    SSdbRow *pRow = *ppRow;

140,760,119✔

452

    if (pRow == NULL) {

140,760,119✔

457

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

140,760,119✔

458

    sdbPrintOper(pSdb, pRow, "fetch");

140,760,119✔

459

    *ppObj = pRow->pObj;

140,760,119✔

460

    *status = pRow->status;

140,760,119✔

461

    break;

140,760,119✔

463

  if (lock) {

175,067,196✔

464

    sdbUnLock(pSdb, type);

173,189,791✔

467

  return ppRow;

175,067,196✔

470

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

93,480,790✔

471

  if (pIter == NULL) return;

93,480,790✔

472

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

93,394,577✔

473

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

93,394,577✔

474

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

93,394,577✔

475

  if (hash == NULL) return;

93,394,577✔

477

  int32_t type = pRow->type;

93,394,577✔

478

  sdbReadLock(pSdb, type);

93,394,577✔

479

  taosHashCancelIterate(hash, pIter);

93,394,577✔

480

  sdbUnLock(pSdb, type);

93,394,577✔

483

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

107✔

484

  if (pIter == NULL) return;

107✔

485

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

107✔

486

  SHashObj *hash = sdbGetHash(pSdb, type);

107✔

487

  if (hash == NULL) return;

107✔

489

  sdbReadLock(pSdb, type);

107✔

490

  taosHashCancelIterate(hash, pIter);

107✔

491

  sdbUnLock(pSdb, type);

107✔

494

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

10,470,723✔

495

  SHashObj *hash = sdbGetHash(pSdb, type);

10,470,723✔

496

  if (hash == NULL) return;

10,470,723✔

498

  sdbReadLock(pSdb, type);

10,470,723✔

500

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

10,470,723✔

501

  while (ppRow != NULL) {

43,733,501✔

502

    SSdbRow *pRow = *ppRow;

33,276,422✔

503

    if (pRow->status == SDB_STATUS_READY) {

33,276,422✔

504

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

31,222,026✔

505

      if (!isContinue) {

31,222,026✔

506

        taosHashCancelIterate(hash, ppRow);

13,644✔

507

        break;

13,644✔

511

    ppRow = taosHashIterate(hash, ppRow);

33,262,778✔

514

  sdbUnLock(pSdb, type);

10,470,723✔

517

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

194,736,597✔

518

  SHashObj *hash = sdbGetHash(pSdb, type);

194,736,597✔

519

  if (hash == NULL) return 0;

194,737,797✔

521

  sdbReadLock(pSdb, type);

194,737,797✔

522

  int32_t size = taosHashGetSize(hash);

194,737,199✔

523

  sdbUnLock(pSdb, type);

194,736,521✔

525

  return size;

194,737,570✔

528

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

20,103,777✔

529

  SHashObj *hash = sdbGetHash(pSdb, type);

20,103,777✔

530

  if (hash == NULL) return -1;

20,103,777✔

532

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

20,103,777✔

534

  int32_t maxId = 0;

20,103,777✔

535

  sdbReadLock(pSdb, type);

20,103,777✔

537

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

20,103,777✔

538

  while (ppRow != NULL) {

34,186,211✔

539

    SSdbRow *pRow = *ppRow;

14,082,434✔

540

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

14,082,434✔

541

    maxId = TMAX(id, maxId);

14,082,434✔

542

    ppRow = taosHashIterate(hash, ppRow);

14,082,434✔

545

  sdbUnLock(pSdb, type);

20,103,777✔

546

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

20,103,777✔

547

  return maxId + 1;

20,103,777✔

550

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

134,267,562✔

551

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

134,267,562✔

556

  return pSdb->tableVer[type];

134,267,562✔

572

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

459,571✔

573

  SHashObj *hash = sdbGetHash(pSdb, type);

459,571✔

574

  if (hash == NULL) return false;

459,571✔

575

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

459,571✔

577

  sdbReadLock(pSdb, type);

459,571✔

578

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

459,571✔

579

  sdbUnLock(pSdb, type);

459,571✔

581

  return (NULL != p);

459,571✔

taosdata / TDengine / #4871

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

taosdata / TDengine / #4871

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