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

21

const char *sdbTableName(ESdbType type) {

393,248,667✔

22

  switch (type) {

393,248,667✔

23

    case SDB_TRANS:

62,335,165✔

24

      return "trans";

62,335,165✔

25

    case SDB_CLUSTER:

3,749,321✔

26

      return "cluster";

3,749,321✔

27

    case SDB_MNODE:

4,237,946✔

28

      return "mnode";

4,237,946✔

29

    case SDB_QNODE:

2,235,629✔

30

      return "qnode";

2,235,629✔

31

    case SDB_SNODE:

4,292,503✔

32

      return "snode";

4,292,503✔

33

    case SDB_DNODE:

7,996,174✔

34

      return "dnode";

7,996,174✔

35

    case SDB_USER:

7,983,690✔

36

      return "user";

7,983,690✔

37

    case SDB_AUTH:

1,596✔

38

      return "auth";

1,596✔

39

    case SDB_ACCT:

3,597,187✔

40

      return "acct";

3,597,187✔

41

    case SDB_STREAM_CK:

1,596✔

42

      return "stream_ck";

1,596✔

43

    case SDB_STREAM:

2,768,326✔

44

      return "stream";

2,768,326✔

45

    case SDB_OFFSET:

1,596✔

46

      return "offset";

1,596✔

47

    case SDB_SUBSCRIBE:

2,445,870✔

48

      return "subscribe";

2,445,870✔

49

    case SDB_CONSUMER:

2,808,505✔

50

      return "consumer";

2,808,505✔

51

    case SDB_TOPIC:

2,347,934✔

52

      return "topic";

2,347,934✔

53

    case SDB_VGROUP:

31,055,627✔

54

      return "vgroup";

31,055,627✔

55

    case SDB_SMA:

2,086,295✔

56

      return "sma";

2,086,295✔

57

    case SDB_STB:

50,760,526✔

58

      return "stb";

50,760,526✔

59

    case SDB_DB:

18,364,779✔

60

      return "db";

18,364,779✔

61

    case SDB_FUNC:

2,167,109✔

62

      return "func";

2,167,109✔

63

    case SDB_IDX:

13,309,240✔

64

      return "idx";

13,309,240✔

65

    case SDB_VIEW:

3,338,855✔

66

      return "view";

3,338,855✔

67

    case SDB_STREAM_SEQ:

1,596✔

68

      return "stream_seq";

1,596✔

69

    case SDB_COMPACT:

2,319,269✔

70

      return "compact";

2,319,269✔

71

    case SDB_COMPACT_DETAIL:

3,110,543✔

72

      return "compact_detail";

3,110,543✔

73

    case SDB_GRANT:

4,276,798✔

74

      return "grant";

4,276,798✔

75

    case SDB_ARBGROUP:

2,163,360✔

76

      return "arb_group";

2,163,360✔

77

    case SDB_ANODE:

2,086,295✔

78

      return "anode";

2,086,295✔

79

    case SDB_BNODE:

2,560,594✔

80

      return "bnode";

2,560,594✔

81

    case SDB_CFG:

130,043,370✔

82

      return "config";

130,043,370✔

83

    case SDB_MOUNT:

2,094,897✔

84

      return "mount";

2,094,897✔

85

    case SDB_MOUNT_LOG:

2,091,254✔

86

      return "mount_log";

2,091,254✔

87

    case SDB_SSMIGRATE:

2,086,295✔

88

      return "ssmigrate";

2,086,295✔

89

    case SDB_SCAN:

2,090,135✔

90

      return "scan";

2,090,135✔

91

    case SDB_SCAN_DETAIL:

2,092,055✔

92

      return "scan_detail";

2,092,055✔

93

    case SDB_RSMA:

2,383,781✔

94

      return "rsma";

2,383,781✔

95

    case SDB_INSTANCE:

1,200,389✔

96

      return "instance";

1,200,389✔

97

    default:

4,762,567✔

98

      return "undefine";

4,762,567✔

102

const char *sdbStatusName(ESdbStatus status) {

160,317,460✔

103

  switch (status) {

160,317,460✔

104

    case SDB_STATUS_CREATING:

8,506,371✔

105

      return "creating";

8,506,371✔

106

    case SDB_STATUS_DROPPING:

2,761,402✔

107

      return "dropping";

2,761,402✔

108

    case SDB_STATUS_READY:

134,344,059✔

109

      return "ready";

134,344,059✔

110

    case SDB_STATUS_DROPPED:

14,622,135✔

111

      return "dropped";

14,622,135✔

112

    case SDB_STATUS_INIT:

83,493✔

113

      return "init";

83,493✔

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,072,734,870✔

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,106,991,286✔

131

  } else if (keyType == SDB_KEY_INT64) {

104,085,400✔

132

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

104,085,594✔

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

979,853,452✔

155

  int32_t  keySize = 0;

979,853,452✔

156

  EKeyType keyType = pSdb->keyTypes[type];

979,853,452✔

158

  if (keyType == SDB_KEY_INT32) {

979,854,539✔

159

    keySize = sizeof(int32_t);

643,431,430✔

160

  } else if (keyType == SDB_KEY_BINARY) {

336,423,109✔

161

    keySize = strlen(pKey) + 1;

333,592,803✔

163

    keySize = sizeof(int64_t);

2,830,306✔

166

  return keySize;

979,854,539✔

169

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

88,830,310✔

170

  int32_t type = pRow->type;

88,830,310✔

171

  sdbWriteLock(pSdb, type);

88,830,310✔

173

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

88,830,310✔

174

  if (pOldRow != NULL) {

88,830,310✔

181

  pRow->refCount = 0;

88,830,310✔

182

  pRow->status = pRaw->status;

88,830,310✔

183

  sdbPrintOper(pSdb, pRow, "insert");

88,830,310✔

185

  int32_t code = 0;

88,830,310✔

186

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

88,830,310✔

192

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

88,830,310✔

193

  if (insertFp != NULL) {

88,830,310✔

194

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

88,830,310✔

195

    if (code != 0) {

88,830,310✔

206

  sdbUnLock(pSdb, type);

88,830,310✔

208

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

88,830,310✔

209

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

24,213,270✔

211

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

88,830,310✔

212

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

790,671✔

214

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

88,830,310✔

216

  return 0;

88,830,310✔

219

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

129,231,097✔

220

  int32_t type = pNewRow->type;

129,231,097✔

221

  sdbWriteLock(pSdb, type);

129,231,097✔

223

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

129,231,097✔

224

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

129,231,097✔

225

    sdbUnLock(pSdb, type);

84,428,670✔

226

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

84,428,670✔

229

  SSdbRow *pOldRow = *ppOldRow;

44,802,427✔

230

  pOldRow->status = pRaw->status;

44,802,427✔

231

  sdbPrintOper(pSdb, pOldRow, "update");

44,802,427✔

233

  int32_t     code = 0;

44,802,427✔

234

  SdbUpdateFp updateFp = pSdb->updateFps[type];

44,802,427✔

235

  if (updateFp != NULL) {

44,802,427✔

236

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

44,802,427✔

238

  sdbUnLock(pSdb, type);

44,802,427✔

241

  sdbFreeRow(pSdb, pNewRow, false);

44,802,427✔

243

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

44,802,427✔

244

  return code;

44,802,427✔

247

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

23,954,624✔

248

  int32_t type = pRow->type;

23,954,624✔

249

  sdbWriteLock(pSdb, type);

23,954,624✔

251

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

23,954,624✔

252

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

23,954,624✔

253

    sdbUnLock(pSdb, type);

9,910✔

254

    sdbFreeRow(pSdb, pRow, false);

9,910✔

255

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

9,910✔

256

    return terrno;

9,910✔

258

  SSdbRow *pOldRow = *ppOldRow;

23,944,714✔

259

  pOldRow->status = pRaw->status;

23,944,714✔

261

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

23,944,714✔

262

  sdbPrintOper(pSdb, pOldRow, "delete");

23,944,714✔

264

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

23,944,714✔

270

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

23,944,714✔

271

  sdbUnLock(pSdb, type);

23,944,714✔

273

  sdbFreeRow(pSdb, pRow, false);

23,944,714✔

275

  sdbCheckRow(pSdb, pOldRow);

23,944,714✔

276

  return 0;

23,944,714✔

279

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

157,587,361✔

280

  if (pRaw->type == SDB_CFG) {

157,587,361✔

281

    mTrace("sdb write cfg");

53,532,239✔

283

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

157,587,361✔

284

  if (hash == NULL) return terrno;

157,587,361✔

286

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

157,587,361✔

287

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

157,587,361✔

288

  if (pRow == NULL) return terrno;

157,587,361✔

290

  pRow->type = pRaw->type;

157,587,361✔

292

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

157,587,361✔

293

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

157,587,361✔

295

  switch (pRaw->status) {

157,587,361✔

296

    case SDB_STATUS_CREATING:

4,401,640✔

297

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

4,401,640✔

298

      break;

4,401,640✔

299

    case SDB_STATUS_READY:

129,231,097✔

302

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

129,231,097✔

303

      break;

129,231,097✔

304

    case SDB_STATUS_DROPPED:

23,954,624✔

305

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

23,954,624✔

306

      break;

23,954,624✔

309

  return code;

157,587,361✔

312

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

18,853,710✔

313

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

18,853,710✔

314

  sdbFreeRaw(pRaw);

18,853,710✔

315

  return code;

18,853,710✔

318

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

821,839,710✔

319

  terrno = 0;

821,839,710✔

321

  SHashObj *hash = sdbGetHash(pSdb, type);

821,839,605✔

322

  if (hash == NULL) return NULL;

821,840,982✔

324

  void   *pRet = NULL;

821,840,982✔

325

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

821,840,982✔

327

  sdbReadLock(pSdb, type);

821,840,545✔

329

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

821,843,529✔

330

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

821,842,575✔

331

    sdbUnLock(pSdb, type);

187,893,785✔

332

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

187,893,678✔

333

    return NULL;

187,893,678✔

336

  SSdbRow *pRow = *ppRow;

633,949,096✔

337

  switch (pRow->status) {

633,949,096✔

338

    case SDB_STATUS_READY:

631,711,259✔

339

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

631,711,259✔

340

      pRet = pRow->pObj;

631,712,448✔

341

      sdbPrintOper(pSdb, pRow, "acquire");

631,712,778✔

342

      break;

631,711,469✔

343

    case SDB_STATUS_CREATING:

1,811,244✔

344

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

1,811,244✔

345

      break;

1,811,244✔

346

    case SDB_STATUS_DROPPING:

424,969✔

347

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

424,969✔

348

      break;

424,969✔

354

  if (pRet == NULL) {

633,947,682✔

355

    if (!onlyReady) {

2,236,213✔

363

  sdbUnLock(pSdb, type);

633,947,682✔

364

  return pRet;

633,950,143✔

367

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

821,147,656✔

368

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

688,988✔

369

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

688,988✔

372

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

23,944,714✔

373

  int32_t type = pRow->type;

23,944,714✔

374

  sdbWriteLock(pSdb, type);

23,944,714✔

376

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

23,944,714✔

377

  sdbPrintOper(pSdb, pRow, "check");

23,944,714✔

378

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

23,944,714✔

379

    sdbFreeRow(pSdb, pRow, true);

4,752,027✔

382

  sdbUnLock(pSdb, type);

23,944,714✔

383

23,944,714✔

385

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

1,430,113,814✔

386

  if (pObj == NULL) return;

1,430,113,814✔

388

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

1,413,976,113✔

389

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

1,413,980,385✔

391

  int32_t type = pRow->type;

1,413,976,552✔

392

  if (lock) {

1,413,980,295✔

393

    sdbWriteLock(pSdb, type);

1,412,828,668✔

396

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

1,413,993,541✔

397

  sdbPrintOper(pSdb, pRow, "release");

1,413,994,922✔

398

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

1,413,986,579✔

399

    sdbFreeRow(pSdb, pRow, true);

19,192,687✔

401

  if (ref < 0) {

1,413,986,898✔

402

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

1,543,546✔

405

  if (lock) {

1,413,990,117✔

406

    sdbUnLock(pSdb, type);

1,412,842,756✔

410

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

1,428,967,267✔

412

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

865,392,500✔

413

  *ppObj = NULL;

865,392,500✔

415

  SHashObj *hash = sdbGetHash(pSdb, type);

865,393,046✔

416

  if (hash == NULL) return NULL;

865,387,475✔

418

  sdbReadLock(pSdb, type);

865,387,475✔

420

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

865,394,442✔

421

  while (ppRow != NULL) {

873,069,853✔

422

    SSdbRow *pRow = *ppRow;

643,969,588✔

423

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

643,969,726✔

424

      ppRow = taosHashIterate(hash, ppRow);

7,679,926✔

425

      continue;

7,674,242✔

428

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

636,289,595✔

430

    sdbPrintOper(pSdb, pRow, "fetch");

636,293,153✔

431

    *ppObj = pRow->pObj;

636,280,633✔

432

    break;

636,285,237✔

434

  sdbUnLock(pSdb, type);

865,385,502✔

436

  return ppRow;

865,393,621✔

439

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

181,306,611✔

440

  *ppObj = NULL;

181,306,611✔

442

  SHashObj *hash = sdbGetHash(pSdb, type);

181,306,611✔

443

  if (hash == NULL) return NULL;

181,306,611✔

445

  if (lock) {

181,306,611✔

446

    sdbReadLock(pSdb, type);

179,382,400✔

449

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

181,306,611✔

450

  while (ppRow != NULL) {

181,306,611✔

451

    SSdbRow *pRow = *ppRow;

146,001,211✔

452

    if (pRow == NULL) {

146,001,211✔

457

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

146,001,211✔

458

    sdbPrintOper(pSdb, pRow, "fetch");

146,001,211✔

459

    *ppObj = pRow->pObj;

146,001,211✔

460

    *status = pRow->status;

146,001,211✔

461

    break;

146,001,211✔

463

  if (lock) {

181,306,611✔

464

    sdbUnLock(pSdb, type);

179,382,400✔

467

  return ppRow;

181,306,611✔

470

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

89,435,534✔

471

  if (pIter == NULL) return;

89,435,534✔

472

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

89,339,973✔

473

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

89,339,973✔

474

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

89,339,973✔

475

  if (hash == NULL) return;

89,339,973✔

477

  int32_t type = pRow->type;

89,339,973✔

478

  sdbReadLock(pSdb, type);

89,339,973✔

479

  taosHashCancelIterate(hash, pIter);

89,339,973✔

480

  sdbUnLock(pSdb, type);

89,339,973✔

483

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

124✔

484

  if (pIter == NULL) return;

124✔

485

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

124✔

486

  SHashObj *hash = sdbGetHash(pSdb, type);

124✔

487

  if (hash == NULL) return;

124✔

489

  sdbReadLock(pSdb, type);

124✔

490

  taosHashCancelIterate(hash, pIter);

124✔

491

  sdbUnLock(pSdb, type);

124✔

494

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

10,717,082✔

495

  SHashObj *hash = sdbGetHash(pSdb, type);

10,717,082✔

496

  if (hash == NULL) return;

10,717,082✔

498

  sdbReadLock(pSdb, type);

10,717,082✔

500

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

10,717,082✔

501

  while (ppRow != NULL) {

44,733,356✔

502

    SSdbRow *pRow = *ppRow;

34,030,676✔

503

    if (pRow->status == SDB_STATUS_READY) {

34,030,676✔

504

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

31,988,620✔

505

      if (!isContinue) {

31,988,620✔

506

        taosHashCancelIterate(hash, ppRow);

14,402✔

507

        break;

14,402✔

511

    ppRow = taosHashIterate(hash, ppRow);

34,016,274✔

514

  sdbUnLock(pSdb, type);

10,717,082✔

517

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

192,499,901✔

518

  SHashObj *hash = sdbGetHash(pSdb, type);

192,499,901✔

519

  if (hash == NULL) return 0;

192,498,685✔

521

  sdbReadLock(pSdb, type);

192,498,685✔

522

  int32_t size = taosHashGetSize(hash);

192,498,093✔

523

  sdbUnLock(pSdb, type);

192,495,697✔

525

  return size;

192,499,902✔

528

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

20,447,781✔

529

  SHashObj *hash = sdbGetHash(pSdb, type);

20,447,781✔

530

  if (hash == NULL) return -1;

20,447,781✔

532

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

20,447,781✔

534

  int32_t maxId = 0;

20,447,781✔

535

  sdbReadLock(pSdb, type);

20,447,781✔

537

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

20,447,781✔

538

  while (ppRow != NULL) {

35,073,623✔

539

    SSdbRow *pRow = *ppRow;

14,625,842✔

540

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

14,625,842✔

541

    maxId = TMAX(id, maxId);

14,625,842✔

542

    ppRow = taosHashIterate(hash, ppRow);

14,625,842✔

545

  sdbUnLock(pSdb, type);

20,447,781✔

546

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

20,447,781✔

547

  return maxId + 1;

20,447,781✔

550

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

132,694,231✔

551

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

132,694,231✔

556

  return pSdb->tableVer[type];

132,694,231✔

572

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

426,404✔

573

  SHashObj *hash = sdbGetHash(pSdb, type);

426,404✔

574

  if (hash == NULL) return false;

426,404✔

575

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

426,404✔

577

  sdbReadLock(pSdb, type);

426,404✔

578

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

426,404✔

579

  sdbUnLock(pSdb, type);

426,404✔

581

  return (NULL != p);

426,404✔

taosdata / TDengine / #4874

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) {	393,248,667✔
22	switch (type) {	393,248,667✔
23	case SDB_TRANS:	62,335,165✔
24	return "trans";	62,335,165✔
25	case SDB_CLUSTER:	3,749,321✔
26	return "cluster";	3,749,321✔
27	case SDB_MNODE:	4,237,946✔
28	return "mnode";	4,237,946✔
29	case SDB_QNODE:	2,235,629✔
30	return "qnode";	2,235,629✔
31	case SDB_SNODE:	4,292,503✔
32	return "snode";	4,292,503✔
33	case SDB_DNODE:	7,996,174✔
34	return "dnode";	7,996,174✔
35	case SDB_USER:	7,983,690✔
36	return "user";	7,983,690✔
37	case SDB_AUTH:	1,596✔
38	return "auth";	1,596✔
39	case SDB_ACCT:	3,597,187✔
40	return "acct";	3,597,187✔
41	case SDB_STREAM_CK:	1,596✔
42	return "stream_ck";	1,596✔
43	case SDB_STREAM:	2,768,326✔
44	return "stream";	2,768,326✔
45	case SDB_OFFSET:	1,596✔
46	return "offset";	1,596✔
47	case SDB_SUBSCRIBE:	2,445,870✔
48	return "subscribe";	2,445,870✔
49	case SDB_CONSUMER:	2,808,505✔
50	return "consumer";	2,808,505✔
51	case SDB_TOPIC:	2,347,934✔
52	return "topic";	2,347,934✔
53	case SDB_VGROUP:	31,055,627✔
54	return "vgroup";	31,055,627✔
55	case SDB_SMA:	2,086,295✔
56	return "sma";	2,086,295✔
57	case SDB_STB:	50,760,526✔
58	return "stb";	50,760,526✔
59	case SDB_DB:	18,364,779✔
60	return "db";	18,364,779✔
61	case SDB_FUNC:	2,167,109✔
62	return "func";	2,167,109✔
63	case SDB_IDX:	13,309,240✔
64	return "idx";	13,309,240✔
65	case SDB_VIEW:	3,338,855✔
66	return "view";	3,338,855✔
67	case SDB_STREAM_SEQ:	1,596✔
68	return "stream_seq";	1,596✔
69	case SDB_COMPACT:	2,319,269✔
70	return "compact";	2,319,269✔
71	case SDB_COMPACT_DETAIL:	3,110,543✔
72	return "compact_detail";	3,110,543✔
73	case SDB_GRANT:	4,276,798✔
74	return "grant";	4,276,798✔
75	case SDB_ARBGROUP:	2,163,360✔
76	return "arb_group";	2,163,360✔
77	case SDB_ANODE:	2,086,295✔
78	return "anode";	2,086,295✔
79	case SDB_BNODE:	2,560,594✔
80	return "bnode";	2,560,594✔
81	case SDB_CFG:	130,043,370✔
82	return "config";	130,043,370✔
83	case SDB_MOUNT:	2,094,897✔
84	return "mount";	2,094,897✔
85	case SDB_MOUNT_LOG:	2,091,254✔
86	return "mount_log";	2,091,254✔
87	case SDB_SSMIGRATE:	2,086,295✔
88	return "ssmigrate";	2,086,295✔
89	case SDB_SCAN:	2,090,135✔
90	return "scan";	2,090,135✔
91	case SDB_SCAN_DETAIL:	2,092,055✔
92	return "scan_detail";	2,092,055✔
93	case SDB_RSMA:	2,383,781✔
94	return "rsma";	2,383,781✔
95	case SDB_INSTANCE:	1,200,389✔
96	return "instance";	1,200,389✔
97	default:	4,762,567✔
98	return "undefine";	4,762,567✔
99	}
100	}
101
102	const char *sdbStatusName(ESdbStatus status) {	160,317,460✔
103	switch (status) {	160,317,460✔
104	case SDB_STATUS_CREATING:	8,506,371✔
105	return "creating";	8,506,371✔
106	case SDB_STATUS_DROPPING:	2,761,402✔
107	return "dropping";	2,761,402✔
108	case SDB_STATUS_READY:	134,344,059✔
109	return "ready";	134,344,059✔
110	case SDB_STATUS_DROPPED:	14,622,135✔
111	return "dropped";	14,622,135✔
112	case SDB_STATUS_INIT:	83,493✔
113	return "init";	83,493✔
UNCOV 114	case SDB_STATUS_UPDATE:	×
UNCOV 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,072,734,870✔
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,106,991,286✔
130	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
131	} else if (keyType == SDB_KEY_INT64) {	104,085,400✔
132	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	104,085,594✔
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;	×
UNCOV 142	return NULL;	×
143	}
144
145	SHashObj *hash = pSdb->hashObjs[type];	2,147,483,647✔
146	if (hash == NULL) {	2,147,483,647✔
UNCOV 147	terrno = TSDB_CODE_APP_ERROR;	×
UNCOV 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) {	979,853,452✔
155	int32_t keySize = 0;	979,853,452✔
156	EKeyType keyType = pSdb->keyTypes[type];	979,853,452✔
157
158	if (keyType == SDB_KEY_INT32) {	979,854,539✔
159	keySize = sizeof(int32_t);	643,431,430✔
160	} else if (keyType == SDB_KEY_BINARY) {	336,423,109✔
161	keySize = strlen(pKey) + 1;	333,592,803✔
162	} else {
163	keySize = sizeof(int64_t);	2,830,306✔
164	}
165
166	return keySize;	979,854,539✔
167	}
168
169	static int32_t sdbInsertRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	88,830,310✔
170	int32_t type = pRow->type;	88,830,310✔
171	sdbWriteLock(pSdb, type);	88,830,310✔
172
173	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	88,830,310✔
174	if (pOldRow != NULL) {	88,830,310✔
UNCOV 175	sdbUnLock(pSdb, type);	×
UNCOV 176	sdbFreeRow(pSdb, pRow, false);	×
177	terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;	×
178	return terrno;	×
179	}
180
181	pRow->refCount = 0;	88,830,310✔
182	pRow->status = pRaw->status;	88,830,310✔
183	sdbPrintOper(pSdb, pRow, "insert");	88,830,310✔
184
185	int32_t code = 0;	88,830,310✔
186	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	88,830,310✔
UNCOV 187	sdbUnLock(pSdb, type);	×
UNCOV 188	sdbFreeRow(pSdb, pRow, false);	×
189	return code;	×
190	}
191
192	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	88,830,310✔
193	if (insertFp != NULL) {	88,830,310✔
194	code = (*insertFp)(pSdb, pRow->pObj);	88,830,310✔
195	if (code != 0) {	88,830,310✔
UNCOV 196	if (taosHashRemove(hash, pRow->pObj, keySize) != 0) {	×
UNCOV 197	mError("failed to remove row from hash");	×
198	}
199	sdbFreeRow(pSdb, pRow, false);	×
UNCOV 200	sdbUnLock(pSdb, type);	×
201	terrno = code;	×
202	return terrno;	×
203	}
204	}
205
206	sdbUnLock(pSdb, type);	88,830,310✔
207
208	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	88,830,310✔
209	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	24,213,270✔
210	}
211	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	88,830,310✔
212	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	790,671✔
213	}
214	pSdb->tableVer[pRow->type]++;	88,830,310✔
215
216	return 0;	88,830,310✔
217	}
218
219	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	129,231,097✔
220	int32_t type = pNewRow->type;	129,231,097✔
221	sdbWriteLock(pSdb, type);	129,231,097✔
222
223	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	129,231,097✔
224	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	129,231,097✔
225	sdbUnLock(pSdb, type);	84,428,670✔
226	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	84,428,670✔
227	}
228
229	SSdbRow pOldRow = ppOldRow;	44,802,427✔
230	pOldRow->status = pRaw->status;	44,802,427✔
231	sdbPrintOper(pSdb, pOldRow, "update");	44,802,427✔
232
233	int32_t code = 0;	44,802,427✔
234	SdbUpdateFp updateFp = pSdb->updateFps[type];	44,802,427✔
235	if (updateFp != NULL) {	44,802,427✔
236	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	44,802,427✔
237	}
238	sdbUnLock(pSdb, type);	44,802,427✔
239
240	// sdbUnLock(pSdb, type);
241	sdbFreeRow(pSdb, pNewRow, false);	44,802,427✔
242
243	pSdb->tableVer[pOldRow->type]++;	44,802,427✔
244	return code;	44,802,427✔
245	}
246
247	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	23,954,624✔
248	int32_t type = pRow->type;	23,954,624✔
249	sdbWriteLock(pSdb, type);	23,954,624✔
250
251	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	23,954,624✔
252	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	23,954,624✔
253	sdbUnLock(pSdb, type);	9,910✔
254	sdbFreeRow(pSdb, pRow, false);	9,910✔
255	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	9,910✔
256	return terrno;	9,910✔
257	}
258	SSdbRow pOldRow = ppOldRow;	23,944,714✔
259	pOldRow->status = pRaw->status;	23,944,714✔
260
261	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	23,944,714✔
262	sdbPrintOper(pSdb, pOldRow, "delete");	23,944,714✔
263
264	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	23,944,714✔
UNCOV 265	sdbUnLock(pSdb, type);	×
UNCOV 266	sdbFreeRow(pSdb, pRow, false);	×
267	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	×
268	return terrno;	×
269	}
270	pSdb->tableVer[pOldRow->type]++;	23,944,714✔
271	sdbUnLock(pSdb, type);	23,944,714✔
272
273	sdbFreeRow(pSdb, pRow, false);	23,944,714✔
274
275	sdbCheckRow(pSdb, pOldRow);	23,944,714✔
276	return 0;	23,944,714✔
277	}
278
279	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	157,587,361✔
280	if (pRaw->type == SDB_CFG) {	157,587,361✔
281	mTrace("sdb write cfg");	53,532,239✔
282	}
283	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	157,587,361✔
284	if (hash == NULL) return terrno;	157,587,361✔
285
286	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	157,587,361✔
287	SSdbRow pRow = (decodeFp)(pRaw);	157,587,361✔
288	if (pRow == NULL) return terrno;	157,587,361✔
289
290	pRow->type = pRaw->type;	157,587,361✔
291
292	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	157,587,361✔
293	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	157,587,361✔
294
295	switch (pRaw->status) {	157,587,361✔
296	case SDB_STATUS_CREATING:	4,401,640✔
297	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	4,401,640✔
298	break;	4,401,640✔
299	case SDB_STATUS_READY:	129,231,097✔
300	case SDB_STATUS_UPDATE:
301	case SDB_STATUS_DROPPING:
302	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	129,231,097✔
303	break;	129,231,097✔
304	case SDB_STATUS_DROPPED:	23,954,624✔
305	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	23,954,624✔
306	break;	23,954,624✔
307	}
308
309	return code;	157,587,361✔
310	}
311
312	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	18,853,710✔
313	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	18,853,710✔
314	sdbFreeRaw(pRaw);	18,853,710✔
315	return code;	18,853,710✔
316	}
317
318	void sdbAcquireAll(SSdb pSdb, ESdbType type, const void *pKey, bool onlyReady) {	821,839,710✔
319	terrno = 0;	821,839,710✔
320
321	SHashObj *hash = sdbGetHash(pSdb, type);	821,839,605✔
322	if (hash == NULL) return NULL;	821,840,982✔
323
324	void *pRet = NULL;	821,840,982✔
325	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	821,840,982✔
326
327	sdbReadLock(pSdb, type);	821,840,545✔
328
329	SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);	821,843,529✔
330	if (ppRow == NULL \|\| *ppRow == NULL) {	821,842,575✔
331	sdbUnLock(pSdb, type);	187,893,785✔
332	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	187,893,678✔
333	return NULL;	187,893,678✔
334	}
335
336	SSdbRow pRow = ppRow;	633,949,096✔
337	switch (pRow->status) {	633,949,096✔
338	case SDB_STATUS_READY:	631,711,259✔
339	(void)atomic_add_fetch_32(&pRow->refCount, 1);	631,711,259✔
340	pRet = pRow->pObj;	631,712,448✔
341	sdbPrintOper(pSdb, pRow, "acquire");	631,712,778✔
342	break;	631,711,469✔
343	case SDB_STATUS_CREATING:	1,811,244✔
344	terrno = TSDB_CODE_SDB_OBJ_CREATING;	1,811,244✔
345	break;	1,811,244✔
346	case SDB_STATUS_DROPPING:	424,969✔
347	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	424,969✔
348	break;	424,969✔
UNCOV 349	default:	×
UNCOV 350	terrno = TSDB_CODE_APP_ERROR;	×
351	break;	×
352	}
353
354	if (pRet == NULL) {	633,947,682✔
355	if (!onlyReady) {	2,236,213✔
UNCOV 356	terrno = 0;	×
UNCOV 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);	633,947,682✔
364	return pRet;	633,950,143✔
365	}
366
367	void sdbAcquire(SSdb pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }	821,147,656✔
368	void sdbAcquireNotReadyObj(SSdb pSdb, ESdbType type, const void *pKey) {	688,988✔
369	return sdbAcquireAll(pSdb, type, pKey, false);	688,988✔
370	}
371
372	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	23,944,714✔
373	int32_t type = pRow->type;	23,944,714✔
374	sdbWriteLock(pSdb, type);	23,944,714✔
375
376	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	23,944,714✔
377	sdbPrintOper(pSdb, pRow, "check");	23,944,714✔
378	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	23,944,714✔
379	sdbFreeRow(pSdb, pRow, true);	4,752,027✔
380	}
381
382	sdbUnLock(pSdb, type);	23,944,714✔
383	}	23,944,714✔
384
385	void sdbReleaseLock(SSdb pSdb, void pObj, bool lock) {	1,430,113,814✔
386	if (pObj == NULL) return;	1,430,113,814✔
387
388	SSdbRow pRow = (SSdbRow )((char *)pObj - sizeof(SSdbRow));	1,413,976,113✔
389	if (pRow->type >= SDB_MAX) return;	1,413,980,385✔
390
391	int32_t type = pRow->type;	1,413,976,552✔
392	if (lock) {	1,413,980,295✔
393	sdbWriteLock(pSdb, type);	1,412,828,668✔
394	}
395
396	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	1,413,993,541✔
397	sdbPrintOper(pSdb, pRow, "release");	1,413,994,922✔
398	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	1,413,986,579✔
399	sdbFreeRow(pSdb, pRow, true);	19,192,687✔
400	}
401	if (ref < 0) {	1,413,986,898✔
402	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	1,543,546✔
403	}
404
405	if (lock) {	1,413,990,117✔
406	sdbUnLock(pSdb, type);	1,412,842,756✔
407	}
408	}
409
410	void sdbRelease(SSdb pSdb, void pObj) { sdbReleaseLock(pSdb, pObj, true); }	1,428,967,267✔
411
412	void sdbFetch(SSdb pSdb, ESdbType type, void pIter, void *ppObj) {	865,392,500✔
413	*ppObj = NULL;	865,392,500✔
414
415	SHashObj *hash = sdbGetHash(pSdb, type);	865,393,046✔
416	if (hash == NULL) return NULL;	865,387,475✔
417
418	sdbReadLock(pSdb, type);	865,387,475✔
419
420	SSdbRow **ppRow = taosHashIterate(hash, pIter);	865,394,442✔
421	while (ppRow != NULL) {	873,069,853✔
422	SSdbRow pRow = ppRow;	643,969,588✔
423	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	643,969,726✔
424	ppRow = taosHashIterate(hash, ppRow);	7,679,926✔
425	continue;	7,674,242✔
426	}
427
428	(void) atomic_add_fetch_32(&pRow->refCount, 1);	636,289,595✔
429
430	sdbPrintOper(pSdb, pRow, "fetch");	636,293,153✔
431	*ppObj = pRow->pObj;	636,280,633✔
432	break;	636,285,237✔
433	}
434	sdbUnLock(pSdb, type);	865,385,502✔
435
436	return ppRow;	865,393,621✔
437	}
438
439	void sdbFetchAll(SSdb pSdb, ESdbType type, void pIter, void ppObj, ESdbStatus status, bool lock) {	181,306,611✔
440	*ppObj = NULL;	181,306,611✔
441
442	SHashObj *hash = sdbGetHash(pSdb, type);	181,306,611✔
443	if (hash == NULL) return NULL;	181,306,611✔
444
445	if (lock) {	181,306,611✔
446	sdbReadLock(pSdb, type);	179,382,400✔
447	}
448
449	SSdbRow **ppRow = taosHashIterate(hash, pIter);	181,306,611✔
450	while (ppRow != NULL) {	181,306,611✔
451	SSdbRow pRow = ppRow;	146,001,211✔
452	if (pRow == NULL) {	146,001,211✔
UNCOV 453	ppRow = taosHashIterate(hash, ppRow);	×
UNCOV 454	continue;	×
455	}
456
457	(void)atomic_add_fetch_32(&pRow->refCount, 1);	146,001,211✔
458	sdbPrintOper(pSdb, pRow, "fetch");	146,001,211✔
459	*ppObj = pRow->pObj;	146,001,211✔
460	*status = pRow->status;	146,001,211✔
461	break;	146,001,211✔
462	}
463	if (lock) {	181,306,611✔
464	sdbUnLock(pSdb, type);	179,382,400✔
465	}
466
467	return ppRow;	181,306,611✔
468	}
469
470	void sdbCancelFetch(SSdb pSdb, void pIter) {	89,435,534✔
471	if (pIter == NULL) return;	89,435,534✔
472	SSdbRow pRow = (SSdbRow **)pIter;	89,339,973✔
473	mTrace("cancel fetch row:%p", pRow);	89,339,973✔
474	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	89,339,973✔
475	if (hash == NULL) return;	89,339,973✔
476
477	int32_t type = pRow->type;	89,339,973✔
478	sdbReadLock(pSdb, type);	89,339,973✔
479	taosHashCancelIterate(hash, pIter);	89,339,973✔
480	sdbUnLock(pSdb, type);	89,339,973✔
481	}
482
483	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	124✔
484	if (pIter == NULL) return;	124✔
485	if (type >= SDB_MAX \|\| type < 0) return;	124✔
486	SHashObj *hash = sdbGetHash(pSdb, type);	124✔
487	if (hash == NULL) return;	124✔
488
489	sdbReadLock(pSdb, type);	124✔
490	taosHashCancelIterate(hash, pIter);	124✔
491	sdbUnLock(pSdb, type);	124✔
492	}
493
494	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	10,717,082✔
495	SHashObj *hash = sdbGetHash(pSdb, type);	10,717,082✔
496	if (hash == NULL) return;	10,717,082✔
497
498	sdbReadLock(pSdb, type);	10,717,082✔
499
500	SSdbRow **ppRow = taosHashIterate(hash, NULL);	10,717,082✔
501	while (ppRow != NULL) {	44,733,356✔
502	SSdbRow pRow = ppRow;	34,030,676✔
503	if (pRow->status == SDB_STATUS_READY) {	34,030,676✔
504	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	31,988,620✔
505	if (!isContinue) {	31,988,620✔
506	taosHashCancelIterate(hash, ppRow);	14,402✔
507	break;	14,402✔
508	}
509	}
510
511	ppRow = taosHashIterate(hash, ppRow);	34,016,274✔
512	}
513
514	sdbUnLock(pSdb, type);	10,717,082✔
515	}
516
517	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	192,499,901✔
518	SHashObj *hash = sdbGetHash(pSdb, type);	192,499,901✔
519	if (hash == NULL) return 0;	192,498,685✔
520
521	sdbReadLock(pSdb, type);	192,498,685✔
522	int32_t size = taosHashGetSize(hash);	192,498,093✔
523	sdbUnLock(pSdb, type);	192,495,697✔
524
525	return size;	192,499,902✔
526	}
527
528	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	20,447,781✔
529	SHashObj *hash = sdbGetHash(pSdb, type);	20,447,781✔
530	if (hash == NULL) return -1;	20,447,781✔
531
532	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	20,447,781✔
533
534	int32_t maxId = 0;	20,447,781✔
535	sdbReadLock(pSdb, type);	20,447,781✔
536
537	SSdbRow **ppRow = taosHashIterate(hash, NULL);	20,447,781✔
538	while (ppRow != NULL) {	35,073,623✔
539	SSdbRow pRow = ppRow;	14,625,842✔
540	int32_t id = (int32_t )pRow->pObj;	14,625,842✔
541	maxId = TMAX(id, maxId);	14,625,842✔
542	ppRow = taosHashIterate(hash, ppRow);	14,625,842✔
543	}
544
545	sdbUnLock(pSdb, type);	20,447,781✔
546	maxId = TMAX(maxId, pSdb->maxId[type]);	20,447,781✔
547	return maxId + 1;	20,447,781✔
548	}
549
550	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	132,694,231✔
551	if (type >= SDB_MAX \|\| type < 0) {	132,694,231✔
UNCOV 552	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
UNCOV 553	return -1;	×
554	}
555
556	return pSdb->tableVer[type];	132,694,231✔
557	}
558
UNCOV 559	bool countValid(SMnode pMnode, void pObj, void p1, void p2, void *p3) {	×
UNCOV 560	int32_t *pInt = p1;	×
561	(*pInt) += 1;	×
562	return true;	×
563	}
564
UNCOV 565	int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {	×
UNCOV 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) {	426,404✔
573	SHashObj *hash = sdbGetHash(pSdb, type);	426,404✔
574	if (hash == NULL) return false;	426,404✔
575	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	426,404✔
576
577	sdbReadLock(pSdb, type);	426,404✔
578	void* p = taosHashGet(hash, pKey, keySize);	426,404✔
579	sdbUnLock(pSdb, type);	426,404✔
580
581	return (NULL != p);	426,404✔
582	}
583
584

taosdata / TDengine / #4874

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