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

21

const char *sdbTableName(ESdbType type) {

344,836,988✔

22

  switch (type) {

344,836,988✔

23

    case SDB_TRANS:

53,716,226✔

24

      return "trans";

53,716,226✔

25

    case SDB_CLUSTER:

2,993,553✔

26

      return "cluster";

2,993,553✔

27

    case SDB_MNODE:

3,158,767✔

28

      return "mnode";

3,158,767✔

29

    case SDB_QNODE:

1,666,840✔

30

      return "qnode";

1,666,840✔

31

    case SDB_SNODE:

2,807,395✔

32

      return "snode";

2,807,395✔

33

    case SDB_DNODE:

5,882,247✔

34

      return "dnode";

5,882,247✔

35

    case SDB_USER:

6,028,280✔

36

      return "user";

6,028,280✔

37

    case SDB_AUTH:

126✔

38

      return "auth";

126✔

39

    case SDB_ACCT:

2,855,835✔

40

      return "acct";

2,855,835✔

41

    case SDB_STREAM_CK:

126✔

42

      return "stream_ck";

126✔

43

    case SDB_STREAM:

2,034,098✔

44

      return "stream";

2,034,098✔

45

    case SDB_OFFSET:

126✔

46

      return "offset";

126✔

47

    case SDB_SUBSCRIBE:

2,585,841✔

48

      return "subscribe";

2,585,841✔

49

    case SDB_CONSUMER:

3,429,662✔

50

      return "consumer";

3,429,662✔

51

    case SDB_TOPIC:

2,257,128✔

52

      return "topic";

2,257,128✔

53

    case SDB_VGROUP:

25,765,406✔

54

      return "vgroup";

25,765,406✔

55

    case SDB_SMA:

1,616,661✔

56

      return "sma";

1,616,661✔

57

    case SDB_STB:

38,876,605✔

58

      return "stb";

38,876,605✔

59

    case SDB_DB:

21,128,648✔

60

      return "db";

21,128,648✔

61

    case SDB_FUNC:

1,678,571✔

62

      return "func";

1,678,571✔

63

    case SDB_IDX:

9,617,546✔

64

      return "idx";

9,617,546✔

65

    case SDB_VIEW:

1,671,600✔

66

      return "view";

1,671,600✔

67

    case SDB_STREAM_SEQ:

126✔

68

      return "stream_seq";

126✔

69

    case SDB_COMPACT:

1,816,443✔

70

      return "compact";

1,816,443✔

71

    case SDB_COMPACT_DETAIL:

2,386,695✔

72

      return "compact_detail";

2,386,695✔

73

    case SDB_GRANT:

3,413,121✔

74

      return "grant";

3,413,121✔

75

    case SDB_ARBGROUP:

1,692,378✔

76

      return "arb_group";

1,692,378✔

77

    case SDB_ANODE:

1,616,661✔

78

      return "anode";

1,616,661✔

79

    case SDB_BNODE:

1,873,358✔

80

      return "bnode";

1,873,358✔

81

    case SDB_CFG:

110,979,514✔

82

      return "config";

110,979,514✔

83

    case SDB_MOUNT:

1,619,739✔

84

      return "mount";

1,619,739✔

85

    case SDB_MOUNT_LOG:

1,618,434✔

86

      return "mount_log";

1,618,434✔

87

    case SDB_SSMIGRATE:

1,616,661✔

88

      return "ssmigrate";

1,616,661✔

89

    case SDB_SCAN:

1,618,011✔

90

      return "scan";

1,618,011✔

91

    case SDB_SCAN_DETAIL:

1,618,686✔

92

      return "scan_detail";

1,618,686✔

93

    case SDB_RSMA:

1,749,717✔

94

      return "rsma";

1,749,717✔

95

    case SDB_RETENTION:

1,700,961✔

96

      return "retention";

1,700,961✔

97

    case SDB_RETENTION_DETAIL:

1,839,771✔

98

      return "retention_detail";

1,839,771✔

99

    case SDB_INSTANCE:

883,527✔

100

      return "instance";

883,527✔

101

    case SDB_ENCRYPT_ALGORITHMS:

7,723,668✔

102

      return "encrypt_algr";

7,723,668✔

103

    case SDB_TOKEN:

1,616,661✔

104

      return "token";

1,616,661✔

105

    case SDB_ROLE:

7,681,569✔

106

      return "role";

7,681,569✔

112

const char *sdbStatusName(ESdbStatus status) {

141,078,965✔

113

  switch (status) {

141,078,965✔

114

    case SDB_STATUS_CREATING:

7,008,334✔

115

      return "creating";

7,008,334✔

116

    case SDB_STATUS_DROPPING:

2,184,514✔

117

      return "dropping";

2,184,514✔

118

    case SDB_STATUS_READY:

119,588,170✔

119

      return "ready";

119,588,170✔

120

    case SDB_STATUS_DROPPED:

12,212,321✔

121

      return "dropped";

12,212,321✔

122

    case SDB_STATUS_INIT:

85,626✔

123

      return "init";

85,626✔

131

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

2,147,483,647✔

133

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

2,147,483,647✔

135

  if (keyType == SDB_KEY_BINARY) {

2,147,483,647✔

136

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

1,070,565,703✔

138

  } else if (keyType == SDB_KEY_INT32) {

1,985,366,609✔

139

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

1,882,753,945✔

141

  } else if (keyType == SDB_KEY_INT64) {

102,612,664✔

142

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

102,612,664✔

147

2,147,483,647✔

149

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

2,147,483,647✔

150

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

2,147,483,647✔

155

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

2,147,483,647✔

156

  if (hash == NULL) {

2,147,483,647✔

161

  return hash;

2,147,483,647✔

164

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

922,625,467✔

165

  int32_t  keySize = 0;

922,625,467✔

166

  EKeyType keyType = pSdb->keyTypes[type];

922,625,467✔

168

  if (keyType == SDB_KEY_INT32) {

922,626,492✔

169

    keySize = sizeof(int32_t);

572,893,539✔

170

  } else if (keyType == SDB_KEY_BINARY) {

349,732,953✔

171

    keySize = strlen(pKey) + 1;

343,149,341✔

173

    keySize = sizeof(int64_t);

6,583,612✔

176

  return keySize;

922,626,492✔

179

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

76,050,412✔

180

  int32_t type = pRow->type;

76,050,412✔

181

  sdbWriteLock(pSdb, type);

76,050,412✔

183

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

76,050,412✔

184

  if (pOldRow != NULL) {

76,050,412✔

191

  pRow->refCount = 0;

76,050,412✔

192

  pRow->status = pRaw->status;

76,050,412✔

193

  sdbPrintOper(pSdb, pRow, "insert");

76,050,412✔

195

  int32_t code = 0;

76,050,412✔

196

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

76,050,412✔

202

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

76,050,412✔

203

  if (insertFp != NULL) {

76,050,412✔

204

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

76,050,412✔

205

    if (code != 0) {

76,050,412✔

216

  sdbUnLock(pSdb, type);

76,050,412✔

218

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

76,050,412✔

219

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

22,603,099✔

221

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

76,050,412✔

222

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

687,708✔

224

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

76,050,412✔

226

  return 0;

76,050,412✔

229

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

109,106,796✔

230

  int32_t type = pNewRow->type;

109,106,796✔

231

  sdbWriteLock(pSdb, type);

109,106,796✔

233

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

109,106,796✔

234

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

109,106,796✔

235

    sdbUnLock(pSdb, type);

72,491,600✔

236

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

72,491,600✔

239

  SSdbRow *pOldRow = *ppOldRow;

36,615,196✔

240

  pOldRow->status = pRaw->status;

36,615,196✔

241

  sdbPrintOper(pSdb, pOldRow, "update");

36,615,196✔

243

  int32_t     code = 0;

36,615,196✔

244

  SdbUpdateFp updateFp = pSdb->updateFps[type];

36,615,196✔

245

  if (updateFp != NULL) {

36,615,196✔

246

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

36,615,196✔

248

  sdbUnLock(pSdb, type);

36,615,196✔

251

  sdbFreeRow(pSdb, pNewRow, false);

36,615,196✔

253

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

36,615,196✔

254

  return code;

36,615,196✔

257

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

20,586,654✔

258

  int32_t type = pRow->type;

20,586,654✔

259

  sdbWriteLock(pSdb, type);

20,586,654✔

261

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

20,586,654✔

262

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

20,586,654✔

263

    sdbUnLock(pSdb, type);

11,589✔

264

    sdbFreeRow(pSdb, pRow, false);

11,589✔

265

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

11,589✔

266

    return terrno;

11,589✔

268

  SSdbRow *pOldRow = *ppOldRow;

20,575,065✔

269

  pOldRow->status = pRaw->status;

20,575,065✔

271

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

20,575,065✔

272

  sdbPrintOper(pSdb, pOldRow, "delete");

20,575,065✔

274

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

20,575,065✔

280

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

20,575,065✔

281

  sdbUnLock(pSdb, type);

20,575,065✔

283

  sdbFreeRow(pSdb, pRow, false);

20,575,065✔

285

  sdbCheckRow(pSdb, pOldRow);

20,575,065✔

286

  return 0;

20,575,065✔

289

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

133,252,262✔

290

  if (pRaw->type == SDB_CFG) {

133,252,262✔

291

    mTrace("sdb write cfg");

43,745,379✔

293

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

133,252,262✔

294

  if (hash == NULL) return terrno;

133,252,262✔

296

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

133,252,262✔

297

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

133,252,262✔

298

  if (pRow == NULL) return terrno;

133,252,262✔

300

  pRow->type = pRaw->type;

133,252,262✔

302

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

133,252,262✔

303

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

133,252,262✔

305

  switch (pRaw->status) {

133,252,262✔

306

    case SDB_STATUS_CREATING:

3,558,812✔

307

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

3,558,812✔

308

      break;

3,558,812✔

309

    case SDB_STATUS_READY:

109,106,796✔

312

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

109,106,796✔

313

      break;

109,106,796✔

314

    case SDB_STATUS_DROPPED:

20,586,654✔

315

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

20,586,654✔

316

      break;

20,586,654✔

319

  return code;

133,252,262✔

322

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

16,350,291✔

323

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

16,350,291✔

324

  sdbFreeRaw(pRaw);

16,350,291✔

325

  return code;

16,350,291✔

328

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

789,155,015✔

329

  terrno = 0;

789,155,015✔

331

  SHashObj *hash = sdbGetHash(pSdb, type);

789,156,086✔

332

  if (hash == NULL) return NULL;

789,151,785✔

334

  void   *pRet = NULL;

789,151,785✔

335

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

789,151,785✔

337

  sdbReadLock(pSdb, type);

789,153,618✔

339

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

789,156,601✔

340

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

789,157,226✔

341

    sdbUnLock(pSdb, type);

164,363,884✔

342

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

164,364,586✔

343

    return NULL;

164,364,586✔

346

  SSdbRow *pRow = *ppRow;

624,793,342✔

347

  switch (pRow->status) {

624,792,865✔

348

    case SDB_STATUS_READY:

623,780,870✔

349

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

623,780,870✔

350

      pRet = pRow->pObj;

623,782,219✔

351

      sdbPrintOper(pSdb, pRow, "acquire");

623,781,928✔

352

      break;

623,780,954✔

353

    case SDB_STATUS_CREATING:

675,732✔

354

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

675,732✔

355

      break;

675,732✔

356

    case SDB_STATUS_DROPPING:

334,891✔

357

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

334,891✔

358

      break;

334,891✔

364

  if (pRet == NULL) {

624,791,577✔

365

    if (!onlyReady) {

1,010,623✔

373

  sdbUnLock(pSdb, type);

624,791,577✔

374

  return pRet;

624,791,628✔

377

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

788,691,171✔

378

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

463,193✔

379

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

463,193✔

382

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

20,575,065✔

383

  int32_t type = pRow->type;

20,575,065✔

384

  sdbWriteLock(pSdb, type);

20,575,065✔

386

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

20,575,065✔

387

  sdbPrintOper(pSdb, pRow, "check");

20,575,065✔

388

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

20,575,065✔

389

    sdbFreeRow(pSdb, pRow, true);

4,040,107✔

392

  sdbUnLock(pSdb, type);

20,575,065✔

393

20,575,065✔

395

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

1,358,471,155✔

396

  if (pObj == NULL) return;

1,358,471,155✔

398

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

1,334,082,633✔

399

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

1,334,089,328✔

401

  int32_t type = pRow->type;

1,334,085,809✔

402

  if (lock) {

1,334,087,240✔

403

    sdbWriteLock(pSdb, type);

1,333,440,560✔

406

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

1,334,094,657✔

407

  sdbPrintOper(pSdb, pRow, "release");

1,334,102,595✔

408

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

1,334,093,376✔

409

    sdbFreeRow(pSdb, pRow, true);

16,534,958✔

411

  if (ref < 0) {

1,334,093,922✔

412

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

7,331,861✔

415

  if (lock) {

1,334,094,920✔

416

    sdbUnLock(pSdb, type);

1,333,444,673✔

420

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

1,357,826,046✔

422

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

744,628,382✔

423

  *ppObj = NULL;

744,628,382✔

425

  SHashObj *hash = sdbGetHash(pSdb, type);

744,627,999✔

426

  if (hash == NULL) return NULL;

744,626,694✔

428

  sdbReadLock(pSdb, type);

744,626,694✔

430

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

744,636,260✔

431

  while (ppRow != NULL) {

749,400,951✔

432

    SSdbRow *pRow = *ppRow;

537,869,023✔

433

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

537,870,242✔

434

      ppRow = taosHashIterate(hash, ppRow);

4,770,330✔

435

      continue;

4,764,737✔

438

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

533,098,144✔

440

    sdbPrintOper(pSdb, pRow, "fetch");

533,101,331✔

441

    *ppObj = pRow->pObj;

533,096,601✔

442

    break;

533,098,726✔

444

  sdbUnLock(pSdb, type);

744,630,654✔

446

  return ppRow;

744,637,296✔

449

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

243,045,322✔

450

  *ppObj = NULL;

243,045,322✔

452

  SHashObj *hash = sdbGetHash(pSdb, type);

243,045,322✔

453

  if (hash == NULL) return NULL;

243,045,322✔

455

  if (lock) {

243,045,322✔

456

    sdbReadLock(pSdb, type);

241,900,722✔

459

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

243,044,628✔

460

  while (ppRow != NULL) {

243,045,322✔

461

    SSdbRow *pRow = *ppRow;

177,192,638✔

462

    if (pRow == NULL) {

177,192,638✔

467

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

177,192,638✔

468

    sdbPrintOper(pSdb, pRow, "fetch");

177,192,638✔

469

    *ppObj = pRow->pObj;

177,192,638✔

470

    *status = pRow->status;

177,192,638✔

471

    break;

177,192,638✔

473

  if (lock) {

243,045,322✔

474

    sdbUnLock(pSdb, type);

241,900,722✔

477

  return ppRow;

243,045,322✔

480

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

92,747,861✔

481

  if (pIter == NULL) return;

92,747,861✔

482

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

81,127,081✔

483

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

81,127,081✔

484

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

81,127,081✔

485

  if (hash == NULL) return;

81,127,774✔

487

  int32_t type = pRow->type;

81,127,774✔

488

  sdbReadLock(pSdb, type);

81,127,774✔

489

  taosHashCancelIterate(hash, pIter);

81,127,774✔

490

  sdbUnLock(pSdb, type);

81,127,771✔

493

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

780✔

494

  if (pIter == NULL) return;

780✔

495

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

780✔

496

  SHashObj *hash = sdbGetHash(pSdb, type);

780✔

497

  if (hash == NULL) return;

780✔

499

  sdbReadLock(pSdb, type);

780✔

500

  taosHashCancelIterate(hash, pIter);

780✔

501

  sdbUnLock(pSdb, type);

780✔

504

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

8,575,052✔

505

  SHashObj *hash = sdbGetHash(pSdb, type);

8,575,052✔

506

  if (hash == NULL) return;

8,575,052✔

508

  sdbReadLock(pSdb, type);

8,575,052✔

510

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

8,575,052✔

511

  while (ppRow != NULL) {

33,993,699✔

512

    SSdbRow *pRow = *ppRow;

25,426,480✔

513

    if (pRow->status == SDB_STATUS_READY) {

25,426,480✔

514

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

24,853,264✔

515

      if (!isContinue) {

24,853,264✔

516

        taosHashCancelIterate(hash, ppRow);

7,833✔

517

        break;

7,833✔

521

    ppRow = taosHashIterate(hash, ppRow);

25,418,647✔

524

  sdbUnLock(pSdb, type);

8,575,052✔

527

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

178,846,881✔

528

  SHashObj *hash = sdbGetHash(pSdb, type);

178,846,881✔

529

  if (hash == NULL) return 0;

178,847,000✔

531

  sdbReadLock(pSdb, type);

178,847,000✔

532

  int32_t size = taosHashGetSize(hash);

178,847,898✔

533

  sdbUnLock(pSdb, type);

178,844,549✔

535

  return size;

178,847,898✔

538

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

18,984,864✔

539

  SHashObj *hash = sdbGetHash(pSdb, type);

18,984,864✔

540

  if (hash == NULL) return -1;

18,984,864✔

542

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

18,984,864✔

544

  int32_t maxId = 0;

18,984,864✔

545

  sdbReadLock(pSdb, type);

18,984,864✔

547

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

18,984,864✔

548

  while (ppRow != NULL) {

31,795,176✔

549

    SSdbRow *pRow = *ppRow;

12,810,312✔

550

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

12,810,312✔

551

    maxId = TMAX(id, maxId);

12,810,312✔

552

    ppRow = taosHashIterate(hash, ppRow);

12,810,312✔

555

  sdbUnLock(pSdb, type);

18,984,864✔

556

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

18,984,864✔

557

  return maxId + 1;

18,984,864✔

560

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

122,091,757✔

561

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

122,091,757✔

566

  return pSdb->tableVer[type];

122,091,757✔

582

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

221,671✔

583

  SHashObj *hash = sdbGetHash(pSdb, type);

221,671✔

584

  if (hash == NULL) return false;

221,671✔

585

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

221,671✔

587

  sdbReadLock(pSdb, type);

221,671✔

588

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

221,671✔

589

  sdbUnLock(pSdb, type);

221,671✔

591

  return (NULL != p);

221,671✔

taosdata / TDengine / #4905

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

taosdata / TDengine / #4905

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