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

21

const char *sdbTableName(ESdbType type) {

379,417,991✔

22

  switch (type) {

379,417,991✔

23

    case SDB_TRANS:

62,014,267✔

24

      return "trans";

62,014,267✔

25

    case SDB_CLUSTER:

3,575,084✔

26

      return "cluster";

3,575,084✔

27

    case SDB_MNODE:

4,019,844✔

28

      return "mnode";

4,019,844✔

29

    case SDB_QNODE:

2,132,508✔

30

      return "qnode";

2,132,508✔

31

    case SDB_SNODE:

4,054,495✔

32

      return "snode";

4,054,495✔

33

    case SDB_DNODE:

7,739,185✔

34

      return "dnode";

7,739,185✔

35

    case SDB_USER:

7,632,146✔

36

      return "user";

7,632,146✔

37

    case SDB_AUTH:

1,550✔

38

      return "auth";

1,550✔

39

    case SDB_ACCT:

3,419,987✔

40

      return "acct";

3,419,987✔

41

    case SDB_STREAM_CK:

1,550✔

42

      return "stream_ck";

1,550✔

43

    case SDB_STREAM:

2,455,733✔

44

      return "stream";

2,455,733✔

45

    case SDB_OFFSET:

1,550✔

46

      return "offset";

1,550✔

47

    case SDB_SUBSCRIBE:

2,304,368✔

48

      return "subscribe";

2,304,368✔

49

    case SDB_CONSUMER:

2,625,893✔

50

      return "consumer";

2,625,893✔

51

    case SDB_TOPIC:

2,221,619✔

52

      return "topic";

2,221,619✔

53

    case SDB_VGROUP:

29,583,749✔

54

      return "vgroup";

29,583,749✔

55

    case SDB_SMA:

1,989,206✔

56

      return "sma";

1,989,206✔

57

    case SDB_STB:

52,253,698✔

58

      return "stb";

52,253,698✔

59

    case SDB_DB:

17,522,668✔

60

      return "db";

17,522,668✔

61

    case SDB_FUNC:

2,065,450✔

62

      return "func";

2,065,450✔

63

    case SDB_IDX:

12,852,225✔

64

      return "idx";

12,852,225✔

65

    case SDB_VIEW:

3,184,310✔

66

      return "view";

3,184,310✔

67

    case SDB_STREAM_SEQ:

1,550✔

68

      return "stream_seq";

1,550✔

69

    case SDB_COMPACT:

2,214,677✔

70

      return "compact";

2,214,677✔

71

    case SDB_COMPACT_DETAIL:

2,981,637✔

72

      return "compact_detail";

2,981,637✔

73

    case SDB_GRANT:

4,086,875✔

74

      return "grant";

4,086,875✔

75

    case SDB_ARBGROUP:

2,059,477✔

76

      return "arb_group";

2,059,477✔

77

    case SDB_ANODE:

1,989,206✔

78

      return "anode";

1,989,206✔

79

    case SDB_BNODE:

2,445,227✔

80

      return "bnode";

2,445,227✔

81

    case SDB_CFG:

123,198,556✔

82

      return "config";

123,198,556✔

83

    case SDB_MOUNT:

1,997,440✔

84

      return "mount";

1,997,440✔

85

    case SDB_MOUNT_LOG:

1,993,952✔

86

      return "mount_log";

1,993,952✔

87

    case SDB_SSMIGRATE:

1,989,206✔

88

      return "ssmigrate";

1,989,206✔

89

    case SDB_SCAN:

1,992,506✔

90

      return "scan";

1,992,506✔

91

    case SDB_SCAN_DETAIL:

1,994,156✔

92

      return "scan_detail";

1,994,156✔

93

    case SDB_RSMA:

2,275,730✔

94

      return "rsma";

2,275,730✔

95

    default:

4,546,711✔

96

      return "undefine";

4,546,711✔

100

const char *sdbStatusName(ESdbStatus status) {

154,345,804✔

101

  switch (status) {

154,345,804✔

102

    case SDB_STATUS_CREATING:

8,240,201✔

103

      return "creating";

8,240,201✔

104

    case SDB_STATUS_DROPPING:

2,679,511✔

105

      return "dropping";

2,679,511✔

106

    case SDB_STATUS_READY:

129,266,347✔

107

      return "ready";

129,266,347✔

108

    case SDB_STATUS_DROPPED:

14,078,897✔

109

      return "dropped";

14,078,897✔

110

    case SDB_STATUS_INIT:

80,848✔

111

      return "init";

80,848✔

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,

1,046,451,814✔

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

103,391,903✔

130

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

103,392,176✔

135

2,147,483,647✔

137

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

2,147,483,647✔

138

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

2,147,483,647✔

143

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

2,147,483,647✔

144

  if (hash == NULL) {

2,147,483,647✔

149

  return hash;

2,147,483,647✔

152

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

978,203,588✔

153

  int32_t  keySize = 0;

978,203,588✔

154

  EKeyType keyType = pSdb->keyTypes[type];

978,203,588✔

156

  if (keyType == SDB_KEY_INT32) {

978,203,437✔

157

    keySize = sizeof(int32_t);

645,717,804✔

158

  } else if (keyType == SDB_KEY_BINARY) {

332,485,633✔

159

    keySize = strlen(pKey) + 1;

329,785,278✔

161

    keySize = sizeof(int64_t);

2,700,355✔

164

  return keySize;

978,203,437✔

167

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

85,466,579✔

168

  int32_t type = pRow->type;

85,466,579✔

169

  sdbWriteLock(pSdb, type);

85,466,579✔

171

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

85,466,579✔

172

  if (pOldRow != NULL) {

85,466,579✔

179

  pRow->refCount = 0;

85,466,579✔

180

  pRow->status = pRaw->status;

85,466,579✔

181

  sdbPrintOper(pSdb, pRow, "insert");

85,466,579✔

183

  int32_t code = 0;

85,466,579✔

184

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

85,466,579✔

190

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

85,466,579✔

191

  if (insertFp != NULL) {

85,466,579✔

192

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

85,466,579✔

193

    if (code != 0) {

85,466,579✔

204

  sdbUnLock(pSdb, type);

85,466,579✔

206

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

85,466,579✔

207

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

23,962,073✔

209

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

85,466,579✔

210

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

750,761✔

212

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

85,466,579✔

214

  return 0;

85,466,579✔

217

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

126,545,905✔

218

  int32_t type = pNewRow->type;

126,545,905✔

219

  sdbWriteLock(pSdb, type);

126,545,905✔

221

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

126,545,905✔

222

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

126,545,905✔

223

    sdbUnLock(pSdb, type);

81,203,795✔

224

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

81,203,795✔

227

  SSdbRow *pOldRow = *ppOldRow;

45,342,110✔

228

  pOldRow->status = pRaw->status;

45,342,110✔

229

  sdbPrintOper(pSdb, pOldRow, "update");

45,342,110✔

231

  int32_t     code = 0;

45,342,110✔

232

  SdbUpdateFp updateFp = pSdb->updateFps[type];

45,342,110✔

233

  if (updateFp != NULL) {

45,342,110✔

234

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

45,342,110✔

236

  sdbUnLock(pSdb, type);

45,342,110✔

239

  sdbFreeRow(pSdb, pNewRow, false);

45,342,110✔

241

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

45,342,110✔

242

  return code;

45,342,110✔

245

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

23,745,282✔

246

  int32_t type = pRow->type;

23,745,282✔

247

  sdbWriteLock(pSdb, type);

23,745,282✔

249

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

23,745,282✔

250

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

23,745,282✔

251

    sdbUnLock(pSdb, type);

9,663✔

252

    sdbFreeRow(pSdb, pRow, false);

9,663✔

253

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

9,663✔

254

    return terrno;

9,663✔

256

  SSdbRow *pOldRow = *ppOldRow;

23,735,619✔

257

  pOldRow->status = pRaw->status;

23,735,619✔

259

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

23,735,619✔

260

  sdbPrintOper(pSdb, pOldRow, "delete");

23,735,619✔

262

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

23,735,619✔

268

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

23,735,619✔

269

  sdbUnLock(pSdb, type);

23,735,619✔

271

  sdbFreeRow(pSdb, pRow, false);

23,735,619✔

273

  sdbCheckRow(pSdb, pOldRow);

23,735,619✔

274

  return 0;

23,735,619✔

277

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

154,553,971✔

278

  if (pRaw->type == SDB_CFG) {

154,553,971✔

279

    mTrace("sdb write cfg");

50,900,282✔

281

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

154,553,971✔

282

  if (hash == NULL) return terrno;

154,553,971✔

284

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

154,553,971✔

285

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

154,553,971✔

286

  if (pRow == NULL) return terrno;

154,553,971✔

288

  pRow->type = pRaw->type;

154,553,971✔

290

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

154,553,971✔

291

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

154,553,971✔

293

  switch (pRaw->status) {

154,553,971✔

294

    case SDB_STATUS_CREATING:

4,262,784✔

295

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

4,262,784✔

296

      break;

4,262,784✔

297

    case SDB_STATUS_READY:

126,545,905✔

300

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

126,545,905✔

301

      break;

126,545,905✔

302

    case SDB_STATUS_DROPPED:

23,745,282✔

303

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

23,745,282✔

304

      break;

23,745,282✔

307

  return code;

154,553,971✔

310

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

18,784,010✔

311

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

18,784,010✔

312

  sdbFreeRaw(pRaw);

18,784,010✔

313

  return code;

18,784,010✔

316

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

823,339,634✔

317

  terrno = 0;

823,339,634✔

319

  SHashObj *hash = sdbGetHash(pSdb, type);

823,339,886✔

320

  if (hash == NULL) return NULL;

823,338,146✔

322

  void   *pRet = NULL;

823,338,146✔

323

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

823,338,146✔

325

  sdbReadLock(pSdb, type);

823,339,726✔

327

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

823,345,172✔

328

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

823,344,954✔

329

    sdbUnLock(pSdb, type);

178,294,966✔

330

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

178,295,490✔

331

    return NULL;

178,295,490✔

334

  SSdbRow *pRow = *ppRow;

645,049,700✔

335

  switch (pRow->status) {

645,049,878✔

336

    case SDB_STATUS_READY:

642,919,462✔

337

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

642,919,462✔

338

      pRet = pRow->pObj;

642,920,285✔

339

      sdbPrintOper(pSdb, pRow, "acquire");

642,921,056✔

340

      break;

642,919,236✔

341

    case SDB_STATUS_CREATING:

1,722,404✔

342

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

1,722,404✔

343

      break;

1,722,404✔

344

    case SDB_STATUS_DROPPING:

406,833✔

345

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

406,833✔

346

      break;

406,833✔

352

  if (pRet == NULL) {

645,048,473✔

353

    if (!onlyReady) {

2,129,237✔

361

  sdbUnLock(pSdb, type);

645,048,473✔

362

  return pRet;

645,048,941✔

365

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

822,686,966✔

366

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

653,070✔

367

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

653,070✔

370

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

23,735,619✔

371

  int32_t type = pRow->type;

23,735,619✔

372

  sdbWriteLock(pSdb, type);

23,735,619✔

374

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

23,735,619✔

375

  sdbPrintOper(pSdb, pRow, "check");

23,735,619✔

376

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

23,735,619✔

377

    sdbFreeRow(pSdb, pRow, true);

4,603,146✔

380

  sdbUnLock(pSdb, type);

23,735,619✔

381

23,735,619✔

383

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

1,448,180,871✔

384

  if (pObj == NULL) return;

1,448,180,871✔

386

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

1,432,568,575✔

387

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

1,432,571,099✔

389

  int32_t type = pRow->type;

1,432,568,849✔

390

  if (lock) {

1,432,569,936✔

391

    sdbWriteLock(pSdb, type);

1,431,480,947✔

394

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

1,432,579,236✔

395

  sdbPrintOper(pSdb, pRow, "release");

1,432,581,273✔

396

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

1,432,575,916✔

397

    sdbFreeRow(pSdb, pRow, true);

19,132,473✔

399

  if (ref < 0) {

1,432,576,890✔

400

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

1,366,265✔

403

  if (lock) {

1,432,573,241✔

404

    sdbUnLock(pSdb, type);

1,431,482,264✔

408

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

1,447,091,181✔

410

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

886,678,015✔

411

  *ppObj = NULL;

886,678,015✔

413

  SHashObj *hash = sdbGetHash(pSdb, type);

886,677,855✔

414

  if (hash == NULL) return NULL;

886,674,853✔

416

  sdbReadLock(pSdb, type);

886,674,853✔

418

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

886,683,764✔

419

  while (ppRow != NULL) {

894,703,776✔

420

    SSdbRow *pRow = *ppRow;

661,672,860✔

421

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

661,673,065✔

422

      ppRow = taosHashIterate(hash, ppRow);

8,022,206✔

423

      continue;

8,017,543✔

426

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

653,650,641✔

428

    sdbPrintOper(pSdb, pRow, "fetch");

653,652,629✔

429

    *ppObj = pRow->pObj;

653,648,827✔

430

    break;

653,648,854✔

432

  sdbUnLock(pSdb, type);

886,679,770✔

434

  return ppRow;

886,682,788✔

437

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

169,241,921✔

438

  *ppObj = NULL;

169,241,921✔

440

  SHashObj *hash = sdbGetHash(pSdb, type);

169,241,921✔

441

  if (hash == NULL) return NULL;

169,241,921✔

443

  if (lock) {

169,241,921✔

444

    sdbReadLock(pSdb, type);

167,411,882✔

447

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

169,241,921✔

448

  while (ppRow != NULL) {

169,241,921✔

449

    SSdbRow *pRow = *ppRow;

136,017,936✔

450

    if (pRow == NULL) {

136,017,936✔

455

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

136,017,936✔

456

    sdbPrintOper(pSdb, pRow, "fetch");

136,017,936✔

457

    *ppObj = pRow->pObj;

136,017,936✔

458

    *status = pRow->status;

136,017,936✔

459

    break;

136,017,936✔

461

  if (lock) {

169,241,921✔

462

    sdbUnLock(pSdb, type);

167,411,882✔

465

  return ppRow;

169,241,921✔

468

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

92,712,274✔

469

  if (pIter == NULL) return;

92,712,274✔

470

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

92,627,517✔

471

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

92,627,535✔

472

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

92,627,535✔

473

  if (hash == NULL) return;

92,627,535✔

475

  int32_t type = pRow->type;

92,627,535✔

476

  sdbReadLock(pSdb, type);

92,627,535✔

477

  taosHashCancelIterate(hash, pIter);

92,627,535✔

478

  sdbUnLock(pSdb, type);

92,627,535✔

481

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

107✔

482

  if (pIter == NULL) return;

107✔

483

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

107✔

484

  SHashObj *hash = sdbGetHash(pSdb, type);

107✔

485

  if (hash == NULL) return;

107✔

487

  sdbReadLock(pSdb, type);

107✔

488

  taosHashCancelIterate(hash, pIter);

107✔

489

  sdbUnLock(pSdb, type);

107✔

492

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

10,329,245✔

493

  SHashObj *hash = sdbGetHash(pSdb, type);

10,329,245✔

494

  if (hash == NULL) return;

10,329,245✔

496

  sdbReadLock(pSdb, type);

10,329,245✔

498

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

10,329,245✔

499

  while (ppRow != NULL) {

42,153,216✔

500

    SSdbRow *pRow = *ppRow;

31,840,354✔

501

    if (pRow->status == SDB_STATUS_READY) {

31,840,354✔

502

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

29,842,454✔

503

      if (!isContinue) {

29,842,454✔

504

        taosHashCancelIterate(hash, ppRow);

16,383✔

505

        break;

16,383✔

509

    ppRow = taosHashIterate(hash, ppRow);

31,823,971✔

512

  sdbUnLock(pSdb, type);

10,329,245✔

515

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

194,157,828✔

516

  SHashObj *hash = sdbGetHash(pSdb, type);

194,157,828✔

517

  if (hash == NULL) return 0;

194,157,271✔

519

  sdbReadLock(pSdb, type);

194,157,271✔

520

  int32_t size = taosHashGetSize(hash);

194,158,196✔

521

  sdbUnLock(pSdb, type);

194,155,592✔

523

  return size;

194,156,707✔

526

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

20,045,825✔

527

  SHashObj *hash = sdbGetHash(pSdb, type);

20,045,825✔

528

  if (hash == NULL) return -1;

20,045,825✔

530

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

20,045,825✔

532

  int32_t maxId = 0;

20,045,825✔

533

  sdbReadLock(pSdb, type);

20,045,825✔

535

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

20,045,825✔

536

  while (ppRow != NULL) {

34,246,146✔

537

    SSdbRow *pRow = *ppRow;

14,200,321✔

538

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

14,200,321✔

539

    maxId = TMAX(id, maxId);

14,200,321✔

540

    ppRow = taosHashIterate(hash, ppRow);

14,200,321✔

543

  sdbUnLock(pSdb, type);

20,045,825✔

544

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

20,045,825✔

545

  return maxId + 1;

20,045,825✔

548

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

132,920,485✔

549

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

132,920,485✔

554

  return pSdb->tableVer[type];

132,920,485✔

570

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

310,705✔

571

  SHashObj *hash = sdbGetHash(pSdb, type);

310,705✔

572

  if (hash == NULL) return false;

310,705✔

573

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

310,705✔

575

  sdbReadLock(pSdb, type);

310,705✔

576

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

310,705✔

577

  sdbUnLock(pSdb, type);

310,705✔

579

  return (NULL != p);

310,705✔

taosdata / TDengine / #4855

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) {	379,417,991✔
22	switch (type) {	379,417,991✔
23	case SDB_TRANS:	62,014,267✔
24	return "trans";	62,014,267✔
25	case SDB_CLUSTER:	3,575,084✔
26	return "cluster";	3,575,084✔
27	case SDB_MNODE:	4,019,844✔
28	return "mnode";	4,019,844✔
29	case SDB_QNODE:	2,132,508✔
30	return "qnode";	2,132,508✔
31	case SDB_SNODE:	4,054,495✔
32	return "snode";	4,054,495✔
33	case SDB_DNODE:	7,739,185✔
34	return "dnode";	7,739,185✔
35	case SDB_USER:	7,632,146✔
36	return "user";	7,632,146✔
37	case SDB_AUTH:	1,550✔
38	return "auth";	1,550✔
39	case SDB_ACCT:	3,419,987✔
40	return "acct";	3,419,987✔
41	case SDB_STREAM_CK:	1,550✔
42	return "stream_ck";	1,550✔
43	case SDB_STREAM:	2,455,733✔
44	return "stream";	2,455,733✔
45	case SDB_OFFSET:	1,550✔
46	return "offset";	1,550✔
47	case SDB_SUBSCRIBE:	2,304,368✔
48	return "subscribe";	2,304,368✔
49	case SDB_CONSUMER:	2,625,893✔
50	return "consumer";	2,625,893✔
51	case SDB_TOPIC:	2,221,619✔
52	return "topic";	2,221,619✔
53	case SDB_VGROUP:	29,583,749✔
54	return "vgroup";	29,583,749✔
55	case SDB_SMA:	1,989,206✔
56	return "sma";	1,989,206✔
57	case SDB_STB:	52,253,698✔
58	return "stb";	52,253,698✔
59	case SDB_DB:	17,522,668✔
60	return "db";	17,522,668✔
61	case SDB_FUNC:	2,065,450✔
62	return "func";	2,065,450✔
63	case SDB_IDX:	12,852,225✔
64	return "idx";	12,852,225✔
65	case SDB_VIEW:	3,184,310✔
66	return "view";	3,184,310✔
67	case SDB_STREAM_SEQ:	1,550✔
68	return "stream_seq";	1,550✔
69	case SDB_COMPACT:	2,214,677✔
70	return "compact";	2,214,677✔
71	case SDB_COMPACT_DETAIL:	2,981,637✔
72	return "compact_detail";	2,981,637✔
73	case SDB_GRANT:	4,086,875✔
74	return "grant";	4,086,875✔
75	case SDB_ARBGROUP:	2,059,477✔
76	return "arb_group";	2,059,477✔
77	case SDB_ANODE:	1,989,206✔
78	return "anode";	1,989,206✔
79	case SDB_BNODE:	2,445,227✔
80	return "bnode";	2,445,227✔
81	case SDB_CFG:	123,198,556✔
82	return "config";	123,198,556✔
83	case SDB_MOUNT:	1,997,440✔
84	return "mount";	1,997,440✔
85	case SDB_MOUNT_LOG:	1,993,952✔
86	return "mount_log";	1,993,952✔
87	case SDB_SSMIGRATE:	1,989,206✔
88	return "ssmigrate";	1,989,206✔
89	case SDB_SCAN:	1,992,506✔
90	return "scan";	1,992,506✔
91	case SDB_SCAN_DETAIL:	1,994,156✔
92	return "scan_detail";	1,994,156✔
93	case SDB_RSMA:	2,275,730✔
94	return "rsma";	2,275,730✔
95	default:	4,546,711✔
96	return "undefine";	4,546,711✔
97	}
98	}
99
100	const char *sdbStatusName(ESdbStatus status) {	154,345,804✔
101	switch (status) {	154,345,804✔
102	case SDB_STATUS_CREATING:	8,240,201✔
103	return "creating";	8,240,201✔
104	case SDB_STATUS_DROPPING:	2,679,511✔
105	return "dropping";	2,679,511✔
106	case SDB_STATUS_READY:	129,266,347✔
107	return "ready";	129,266,347✔
108	case SDB_STATUS_DROPPED:	14,078,897✔
109	return "dropped";	14,078,897✔
110	case SDB_STATUS_INIT:	80,848✔
111	return "init";	80,848✔
112	case SDB_STATUS_UPDATE:	×
113	return "update";	×
114	default:	×
115	return "undefine";	×
116	}
117	}
118
119	void sdbPrintOper(SSdb pSdb, SSdbRow pRow, const char *oper) {	2,147,483,647✔
120	#if 1
121	EKeyType keyType = pSdb->keyTypes[pRow->type];	2,147,483,647✔
122
123	if (keyType == SDB_KEY_BINARY) {	2,147,483,647✔
124	mTrace("%s:%s, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj,	1,046,451,814✔
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) {	103,391,903✔
130	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	103,392,176✔
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✔
UNCOV 139	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
140	return NULL;	×
141	}
142
143	SHashObj *hash = pSdb->hashObjs[type];	2,147,483,647✔
144	if (hash == NULL) {	2,147,483,647✔
145	terrno = TSDB_CODE_APP_ERROR;	×
146	return NULL;	×
147	}
148
149	return hash;	2,147,483,647✔
150	}
151
152	static int32_t sdbGetkeySize(SSdb pSdb, ESdbType type, const void pKey) {	978,203,588✔
153	int32_t keySize = 0;	978,203,588✔
154	EKeyType keyType = pSdb->keyTypes[type];	978,203,588✔
155
156	if (keyType == SDB_KEY_INT32) {	978,203,437✔
157	keySize = sizeof(int32_t);	645,717,804✔
158	} else if (keyType == SDB_KEY_BINARY) {	332,485,633✔
159	keySize = strlen(pKey) + 1;	329,785,278✔
160	} else {
161	keySize = sizeof(int64_t);	2,700,355✔
162	}
163
164	return keySize;	978,203,437✔
165	}
166
167	static int32_t sdbInsertRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	85,466,579✔
168	int32_t type = pRow->type;	85,466,579✔
169	sdbWriteLock(pSdb, type);	85,466,579✔
170
171	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	85,466,579✔
172	if (pOldRow != NULL) {	85,466,579✔
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;	85,466,579✔
180	pRow->status = pRaw->status;	85,466,579✔
181	sdbPrintOper(pSdb, pRow, "insert");	85,466,579✔
182
183	int32_t code = 0;	85,466,579✔
184	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	85,466,579✔
185	sdbUnLock(pSdb, type);	×
186	sdbFreeRow(pSdb, pRow, false);	×
187	return code;	×
188	}
189
190	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	85,466,579✔
191	if (insertFp != NULL) {	85,466,579✔
192	code = (*insertFp)(pSdb, pRow->pObj);	85,466,579✔
193	if (code != 0) {	85,466,579✔
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);	85,466,579✔
205
206	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	85,466,579✔
207	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	23,962,073✔
208	}
209	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	85,466,579✔
210	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	750,761✔
211	}
212	pSdb->tableVer[pRow->type]++;	85,466,579✔
213
214	return 0;	85,466,579✔
215	}
216
217	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	126,545,905✔
218	int32_t type = pNewRow->type;	126,545,905✔
219	sdbWriteLock(pSdb, type);	126,545,905✔
220
221	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	126,545,905✔
222	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	126,545,905✔
223	sdbUnLock(pSdb, type);	81,203,795✔
224	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	81,203,795✔
225	}
226
227	SSdbRow pOldRow = ppOldRow;	45,342,110✔
228	pOldRow->status = pRaw->status;	45,342,110✔
229	sdbPrintOper(pSdb, pOldRow, "update");	45,342,110✔
230
231	int32_t code = 0;	45,342,110✔
232	SdbUpdateFp updateFp = pSdb->updateFps[type];	45,342,110✔
233	if (updateFp != NULL) {	45,342,110✔
234	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	45,342,110✔
235	}
236	sdbUnLock(pSdb, type);	45,342,110✔
237
238	// sdbUnLock(pSdb, type);
239	sdbFreeRow(pSdb, pNewRow, false);	45,342,110✔
240
241	pSdb->tableVer[pOldRow->type]++;	45,342,110✔
242	return code;	45,342,110✔
243	}
244
245	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	23,745,282✔
246	int32_t type = pRow->type;	23,745,282✔
247	sdbWriteLock(pSdb, type);	23,745,282✔
248
249	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	23,745,282✔
250	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	23,745,282✔
251	sdbUnLock(pSdb, type);	9,663✔
252	sdbFreeRow(pSdb, pRow, false);	9,663✔
253	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	9,663✔
254	return terrno;	9,663✔
255	}
256	SSdbRow pOldRow = ppOldRow;	23,735,619✔
257	pOldRow->status = pRaw->status;	23,735,619✔
258
259	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	23,735,619✔
260	sdbPrintOper(pSdb, pOldRow, "delete");	23,735,619✔
261
262	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	23,735,619✔
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]++;	23,735,619✔
269	sdbUnLock(pSdb, type);	23,735,619✔
270
271	sdbFreeRow(pSdb, pRow, false);	23,735,619✔
272
273	sdbCheckRow(pSdb, pOldRow);	23,735,619✔
274	return 0;	23,735,619✔
275	}
276
277	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	154,553,971✔
278	if (pRaw->type == SDB_CFG) {	154,553,971✔
279	mTrace("sdb write cfg");	50,900,282✔
280	}
281	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	154,553,971✔
282	if (hash == NULL) return terrno;	154,553,971✔
283
284	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	154,553,971✔
285	SSdbRow pRow = (decodeFp)(pRaw);	154,553,971✔
286	if (pRow == NULL) return terrno;	154,553,971✔
287
288	pRow->type = pRaw->type;	154,553,971✔
289
290	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	154,553,971✔
291	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	154,553,971✔
292
293	switch (pRaw->status) {	154,553,971✔
294	case SDB_STATUS_CREATING:	4,262,784✔
295	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	4,262,784✔
296	break;	4,262,784✔
297	case SDB_STATUS_READY:	126,545,905✔
298	case SDB_STATUS_UPDATE:
299	case SDB_STATUS_DROPPING:
300	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	126,545,905✔
301	break;	126,545,905✔
302	case SDB_STATUS_DROPPED:	23,745,282✔
303	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	23,745,282✔
304	break;	23,745,282✔
305	}
306
307	return code;	154,553,971✔
308	}
309
310	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	18,784,010✔
311	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	18,784,010✔
312	sdbFreeRaw(pRaw);	18,784,010✔
313	return code;	18,784,010✔
314	}
315
316	void sdbAcquireAll(SSdb pSdb, ESdbType type, const void *pKey, bool onlyReady) {	823,339,634✔
317	terrno = 0;	823,339,634✔
318
319	SHashObj *hash = sdbGetHash(pSdb, type);	823,339,886✔
320	if (hash == NULL) return NULL;	823,338,146✔
321
322	void *pRet = NULL;	823,338,146✔
323	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	823,338,146✔
324
325	sdbReadLock(pSdb, type);	823,339,726✔
326
327	SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);	823,345,172✔
328	if (ppRow == NULL \|\| *ppRow == NULL) {	823,344,954✔
329	sdbUnLock(pSdb, type);	178,294,966✔
330	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	178,295,490✔
331	return NULL;	178,295,490✔
332	}
333
334	SSdbRow pRow = ppRow;	645,049,700✔
335	switch (pRow->status) {	645,049,878✔
336	case SDB_STATUS_READY:	642,919,462✔
337	(void)atomic_add_fetch_32(&pRow->refCount, 1);	642,919,462✔
338	pRet = pRow->pObj;	642,920,285✔
339	sdbPrintOper(pSdb, pRow, "acquire");	642,921,056✔
340	break;	642,919,236✔
341	case SDB_STATUS_CREATING:	1,722,404✔
342	terrno = TSDB_CODE_SDB_OBJ_CREATING;	1,722,404✔
343	break;	1,722,404✔
344	case SDB_STATUS_DROPPING:	406,833✔
345	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	406,833✔
346	break;	406,833✔
347	default:	×
348	terrno = TSDB_CODE_APP_ERROR;	×
349	break;	×
350	}
351
352	if (pRet == NULL) {	645,048,473✔
353	if (!onlyReady) {	2,129,237✔
354	terrno = 0;	×
355	(void)atomic_add_fetch_32(&pRow->refCount, 1);	×
356	pRet = pRow->pObj;	×
357	sdbPrintOper(pSdb, pRow, "acquire");	×
358	}
359	}
360
361	sdbUnLock(pSdb, type);	645,048,473✔
362	return pRet;	645,048,941✔
363	}
364
365	void sdbAcquire(SSdb pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }	822,686,966✔
366	void sdbAcquireNotReadyObj(SSdb pSdb, ESdbType type, const void *pKey) {	653,070✔
367	return sdbAcquireAll(pSdb, type, pKey, false);	653,070✔
368	}
369
370	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	23,735,619✔
371	int32_t type = pRow->type;	23,735,619✔
372	sdbWriteLock(pSdb, type);	23,735,619✔
373
374	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	23,735,619✔
375	sdbPrintOper(pSdb, pRow, "check");	23,735,619✔
376	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	23,735,619✔
377	sdbFreeRow(pSdb, pRow, true);	4,603,146✔
378	}
379
380	sdbUnLock(pSdb, type);	23,735,619✔
381	}	23,735,619✔
382
383	void sdbReleaseLock(SSdb pSdb, void pObj, bool lock) {	1,448,180,871✔
384	if (pObj == NULL) return;	1,448,180,871✔
385
386	SSdbRow pRow = (SSdbRow )((char *)pObj - sizeof(SSdbRow));	1,432,568,575✔
387	if (pRow->type >= SDB_MAX) return;	1,432,571,099✔
388
389	int32_t type = pRow->type;	1,432,568,849✔
390	if (lock) {	1,432,569,936✔
391	sdbWriteLock(pSdb, type);	1,431,480,947✔
392	}
393
394	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	1,432,579,236✔
395	sdbPrintOper(pSdb, pRow, "release");	1,432,581,273✔
396	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	1,432,575,916✔
397	sdbFreeRow(pSdb, pRow, true);	19,132,473✔
398	}
399	if (ref < 0) {	1,432,576,890✔
400	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	1,366,265✔
401	}
402
403	if (lock) {	1,432,573,241✔
404	sdbUnLock(pSdb, type);	1,431,482,264✔
405	}
406	}
407
408	void sdbRelease(SSdb pSdb, void pObj) { sdbReleaseLock(pSdb, pObj, true); }	1,447,091,181✔
409
410	void sdbFetch(SSdb pSdb, ESdbType type, void pIter, void *ppObj) {	886,678,015✔
411	*ppObj = NULL;	886,678,015✔
412
413	SHashObj *hash = sdbGetHash(pSdb, type);	886,677,855✔
414	if (hash == NULL) return NULL;	886,674,853✔
415
416	sdbReadLock(pSdb, type);	886,674,853✔
417
418	SSdbRow **ppRow = taosHashIterate(hash, pIter);	886,683,764✔
419	while (ppRow != NULL) {	894,703,776✔
420	SSdbRow pRow = ppRow;	661,672,860✔
421	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	661,673,065✔
422	ppRow = taosHashIterate(hash, ppRow);	8,022,206✔
423	continue;	8,017,543✔
424	}
425
426	(void) atomic_add_fetch_32(&pRow->refCount, 1);	653,650,641✔
427
428	sdbPrintOper(pSdb, pRow, "fetch");	653,652,629✔
429	*ppObj = pRow->pObj;	653,648,827✔
430	break;	653,648,854✔
431	}
432	sdbUnLock(pSdb, type);	886,679,770✔
433
434	return ppRow;	886,682,788✔
435	}
436
437	void sdbFetchAll(SSdb pSdb, ESdbType type, void pIter, void ppObj, ESdbStatus status, bool lock) {	169,241,921✔
438	*ppObj = NULL;	169,241,921✔
439
440	SHashObj *hash = sdbGetHash(pSdb, type);	169,241,921✔
441	if (hash == NULL) return NULL;	169,241,921✔
442
443	if (lock) {	169,241,921✔
444	sdbReadLock(pSdb, type);	167,411,882✔
445	}
446
447	SSdbRow **ppRow = taosHashIterate(hash, pIter);	169,241,921✔
448	while (ppRow != NULL) {	169,241,921✔
449	SSdbRow pRow = ppRow;	136,017,936✔
450	if (pRow == NULL) {	136,017,936✔
451	ppRow = taosHashIterate(hash, ppRow);	×
452	continue;	×
453	}
454
455	(void)atomic_add_fetch_32(&pRow->refCount, 1);	136,017,936✔
456	sdbPrintOper(pSdb, pRow, "fetch");	136,017,936✔
457	*ppObj = pRow->pObj;	136,017,936✔
458	*status = pRow->status;	136,017,936✔
459	break;	136,017,936✔
460	}
461	if (lock) {	169,241,921✔
462	sdbUnLock(pSdb, type);	167,411,882✔
463	}
464
465	return ppRow;	169,241,921✔
466	}
467
468	void sdbCancelFetch(SSdb pSdb, void pIter) {	92,712,274✔
469	if (pIter == NULL) return;	92,712,274✔
470	SSdbRow pRow = (SSdbRow **)pIter;	92,627,517✔
471	mTrace("cancel fetch row:%p", pRow);	92,627,535✔
472	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	92,627,535✔
473	if (hash == NULL) return;	92,627,535✔
474
475	int32_t type = pRow->type;	92,627,535✔
476	sdbReadLock(pSdb, type);	92,627,535✔
477	taosHashCancelIterate(hash, pIter);	92,627,535✔
478	sdbUnLock(pSdb, type);	92,627,535✔
479	}
480
481	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	107✔
482	if (pIter == NULL) return;	107✔
483	if (type >= SDB_MAX \|\| type < 0) return;	107✔
484	SHashObj *hash = sdbGetHash(pSdb, type);	107✔
485	if (hash == NULL) return;	107✔
486
487	sdbReadLock(pSdb, type);	107✔
488	taosHashCancelIterate(hash, pIter);	107✔
489	sdbUnLock(pSdb, type);	107✔
490	}
491
492	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	10,329,245✔
493	SHashObj *hash = sdbGetHash(pSdb, type);	10,329,245✔
494	if (hash == NULL) return;	10,329,245✔
495
496	sdbReadLock(pSdb, type);	10,329,245✔
497
498	SSdbRow **ppRow = taosHashIterate(hash, NULL);	10,329,245✔
499	while (ppRow != NULL) {	42,153,216✔
500	SSdbRow pRow = ppRow;	31,840,354✔
501	if (pRow->status == SDB_STATUS_READY) {	31,840,354✔
502	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	29,842,454✔
503	if (!isContinue) {	29,842,454✔
504	taosHashCancelIterate(hash, ppRow);	16,383✔
505	break;	16,383✔
506	}
507	}
508
509	ppRow = taosHashIterate(hash, ppRow);	31,823,971✔
510	}
511
512	sdbUnLock(pSdb, type);	10,329,245✔
513	}
514
515	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	194,157,828✔
516	SHashObj *hash = sdbGetHash(pSdb, type);	194,157,828✔
517	if (hash == NULL) return 0;	194,157,271✔
518
519	sdbReadLock(pSdb, type);	194,157,271✔
520	int32_t size = taosHashGetSize(hash);	194,158,196✔
521	sdbUnLock(pSdb, type);	194,155,592✔
522
523	return size;	194,156,707✔
524	}
525
526	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	20,045,825✔
527	SHashObj *hash = sdbGetHash(pSdb, type);	20,045,825✔
528	if (hash == NULL) return -1;	20,045,825✔
529
530	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	20,045,825✔
531
532	int32_t maxId = 0;	20,045,825✔
533	sdbReadLock(pSdb, type);	20,045,825✔
534
535	SSdbRow **ppRow = taosHashIterate(hash, NULL);	20,045,825✔
536	while (ppRow != NULL) {	34,246,146✔
537	SSdbRow pRow = ppRow;	14,200,321✔
538	int32_t id = (int32_t )pRow->pObj;	14,200,321✔
539	maxId = TMAX(id, maxId);	14,200,321✔
540	ppRow = taosHashIterate(hash, ppRow);	14,200,321✔
541	}
542
543	sdbUnLock(pSdb, type);	20,045,825✔
544	maxId = TMAX(maxId, pSdb->maxId[type]);	20,045,825✔
545	return maxId + 1;	20,045,825✔
546	}
547
548	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	132,920,485✔
549	if (type >= SDB_MAX \|\| type < 0) {	132,920,485✔
550	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
551	return -1;	×
552	}
553
554	return pSdb->tableVer[type];	132,920,485✔
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) {	310,705✔
571	SHashObj *hash = sdbGetHash(pSdb, type);	310,705✔
572	if (hash == NULL) return false;	310,705✔
573	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	310,705✔
574
575	sdbReadLock(pSdb, type);	310,705✔
576	void* p = taosHashGet(hash, pKey, keySize);	310,705✔
577	sdbUnLock(pSdb, type);	310,705✔
578
579	return (NULL != p);	310,705✔
580	}
581
582

taosdata / TDengine / #4855

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