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

21

const char *sdbTableName(ESdbType type) {

425,385,316✔

22

  switch (type) {

425,385,316✔

23

    case SDB_TRANS:

63,196,599✔

24

      return "trans";

63,196,599✔

25

    case SDB_CLUSTER:

3,884,384✔

26

      return "cluster";

3,884,384✔

27

    case SDB_MNODE:

4,403,913✔

28

      return "mnode";

4,403,913✔

29

    case SDB_QNODE:

2,303,426✔

30

      return "qnode";

2,303,426✔

31

    case SDB_SNODE:

4,302,399✔

32

      return "snode";

4,302,399✔

33

    case SDB_DNODE:

8,317,558✔

34

      return "dnode";

8,317,558✔

35

    case SDB_USER:

7,260,318✔

36

      return "user";

7,260,318✔

37

    case SDB_AUTH:

242✔

38

      return "auth";

242✔

39

    case SDB_ACCT:

3,721,065✔

40

      return "acct";

3,721,065✔

41

    case SDB_STREAM_CK:

242✔

42

      return "stream_ck";

242✔

43

    case SDB_STREAM:

2,839,441✔

44

      return "stream";

2,839,441✔

45

    case SDB_OFFSET:

242✔

46

      return "offset";

242✔

47

    case SDB_SUBSCRIBE:

2,507,425✔

48

      return "subscribe";

2,507,425✔

49

    case SDB_CONSUMER:

2,849,595✔

50

      return "consumer";

2,849,595✔

51

    case SDB_TOPIC:

2,399,825✔

52

      return "topic";

2,399,825✔

53

    case SDB_VGROUP:

30,875,552✔

54

      return "vgroup";

30,875,552✔

55

    case SDB_SMA:

2,156,757✔

56

      return "sma";

2,156,757✔

57

    case SDB_STB:

51,176,960✔

58

      return "stb";

51,176,960✔

59

    case SDB_DB:

24,257,258✔

60

      return "db";

24,257,258✔

61

    case SDB_FUNC:

2,235,448✔

62

      return "func";

2,235,448✔

63

    case SDB_IDX:

12,953,353✔

64

      return "idx";

12,953,353✔

65

    case SDB_VIEW:

3,399,753✔

66

      return "view";

3,399,753✔

67

    case SDB_STREAM_SEQ:

242✔

68

      return "stream_seq";

242✔

69

    case SDB_COMPACT:

2,389,656✔

70

      return "compact";

2,389,656✔

71

    case SDB_COMPACT_DETAIL:

3,098,685✔

72

      return "compact_detail";

3,098,685✔

73

    case SDB_GRANT:

4,424,006✔

74

      return "grant";

4,424,006✔

75

    case SDB_ARBGROUP:

2,239,663✔

76

      return "arb_group";

2,239,663✔

77

    case SDB_ANODE:

2,156,757✔

78

      return "anode";

2,156,757✔

79

    case SDB_BNODE:

2,630,099✔

80

      return "bnode";

2,630,099✔

81

    case SDB_CFG:

142,285,717✔

82

      return "config";

142,285,717✔

83

    case SDB_MOUNT:

2,165,186✔

84

      return "mount";

2,165,186✔

85

    case SDB_MOUNT_LOG:

2,161,617✔

86

      return "mount_log";

2,161,617✔

87

    case SDB_SSMIGRATE:

2,156,757✔

88

      return "ssmigrate";

2,156,757✔

89

    case SDB_SCAN:

2,160,327✔

90

      return "scan";

2,160,327✔

91

    case SDB_SCAN_DETAIL:

2,162,112✔

92

      return "scan_detail";

2,162,112✔

93

    case SDB_RSMA:

2,305,878✔

94

      return "rsma";

2,305,878✔

95

    case SDB_INSTANCE:

1,252,562✔

96

      return "instance";

1,252,562✔

97

    case SDB_ENCRYPT_ALGORITHMS:

9,936,104✔

98

      return "encrypt_algr";

9,936,104✔

99

    case SDB_TOKEN:

2,157,153✔

100

      return "token";

2,157,153✔

101

    default:

4,661,040✔

102

      return "undefine";

4,661,040✔

106

const char *sdbStatusName(ESdbStatus status) {

170,722,594✔

107

  switch (status) {

170,722,594✔

108

    case SDB_STATUS_CREATING:

8,487,529✔

109

      return "creating";

8,487,529✔

110

    case SDB_STATUS_DROPPING:

2,752,890✔

111

      return "dropping";

2,752,890✔

112

    case SDB_STATUS_READY:

145,028,692✔

113

      return "ready";

145,028,692✔

114

    case SDB_STATUS_DROPPED:

14,363,043✔

115

      return "dropped";

14,363,043✔

116

    case SDB_STATUS_INIT:

90,440✔

117

      return "init";

90,440✔

125

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

2,147,483,647✔

127

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

2,147,483,647✔

129

  if (keyType == SDB_KEY_BINARY) {

2,147,483,647✔

130

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

1,202,806,455✔

132

  } else if (keyType == SDB_KEY_INT32) {

2,147,483,647✔

133

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

2,124,584,200✔

135

  } else if (keyType == SDB_KEY_INT64) {

102,869,081✔

136

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

102,868,974✔

141

2,147,483,647✔

143

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

2,147,483,647✔

144

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

2,147,483,647✔

145

    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;

19✔

149

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

2,147,483,647✔

150

  if (hash == NULL) {

2,147,483,647✔

155

  return hash;

2,147,483,647✔

158

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

994,098,730✔

159

  int32_t  keySize = 0;

994,098,730✔

160

  EKeyType keyType = pSdb->keyTypes[type];

994,098,730✔

162

  if (keyType == SDB_KEY_INT32) {

994,099,096✔

163

    keySize = sizeof(int32_t);

645,301,289✔

164

  } else if (keyType == SDB_KEY_BINARY) {

348,797,807✔

165

    keySize = strlen(pKey) + 1;

346,147,965✔

167

    keySize = sizeof(int64_t);

2,649,842✔

170

  return keySize;

994,099,096✔

173

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

96,704,288✔

174

  int32_t type = pRow->type;

96,704,288✔

175

  sdbWriteLock(pSdb, type);

96,704,288✔

177

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

96,704,288✔

178

  if (pOldRow != NULL) {

96,704,288✔

185

  pRow->refCount = 0;

96,704,288✔

186

  pRow->status = pRaw->status;

96,704,288✔

187

  sdbPrintOper(pSdb, pRow, "insert");

96,704,288✔

189

  int32_t code = 0;

96,704,288✔

190

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

96,704,288✔

196

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

96,704,288✔

197

  if (insertFp != NULL) {

96,704,288✔

198

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

96,704,288✔

199

    if (code != 0) {

96,704,288✔

210

  sdbUnLock(pSdb, type);

96,704,288✔

212

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

96,704,288✔

213

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

27,523,089✔

215

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

96,704,288✔

216

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

754,307✔

218

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

96,704,288✔

220

  return 0;

96,704,288✔

223

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

137,609,710✔

224

  int32_t type = pNewRow->type;

137,609,710✔

225

  sdbWriteLock(pSdb, type);

137,609,710✔

227

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

137,609,710✔

228

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

137,609,710✔

229

    sdbUnLock(pSdb, type);

92,318,863✔

230

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

92,318,863✔

233

  SSdbRow *pOldRow = *ppOldRow;

45,290,847✔

234

  pOldRow->status = pRaw->status;

45,290,847✔

235

  sdbPrintOper(pSdb, pOldRow, "update");

45,290,847✔

237

  int32_t     code = 0;

45,290,847✔

238

  SdbUpdateFp updateFp = pSdb->updateFps[type];

45,290,847✔

239

  if (updateFp != NULL) {

45,290,847✔

240

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

45,290,847✔

242

  sdbUnLock(pSdb, type);

45,290,847✔

245

  sdbFreeRow(pSdb, pNewRow, false);

45,290,847✔

247

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

45,290,847✔

248

  return code;

45,290,847✔

251

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

24,090,107✔

252

  int32_t type = pRow->type;

24,090,107✔

253

  sdbWriteLock(pSdb, type);

24,090,107✔

255

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

24,090,107✔

256

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

24,090,107✔

257

    sdbUnLock(pSdb, type);

10,075✔

258

    sdbFreeRow(pSdb, pRow, false);

10,075✔

259

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

10,075✔

260

    return terrno;

10,075✔

262

  SSdbRow *pOldRow = *ppOldRow;

24,080,032✔

263

  pOldRow->status = pRaw->status;

24,080,032✔

265

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

24,080,032✔

266

  sdbPrintOper(pSdb, pOldRow, "delete");

24,080,032✔

268

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

24,080,032✔

274

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

24,080,032✔

275

  sdbUnLock(pSdb, type);

24,080,032✔

277

  sdbFreeRow(pSdb, pRow, false);

24,080,032✔

279

  sdbCheckRow(pSdb, pOldRow);

24,080,032✔

280

  return 0;

24,080,032✔

283

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

166,085,242✔

284

  if (pRaw->type == SDB_CFG) {

166,085,242✔

285

    mTrace("sdb write cfg");

58,542,610✔

287

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

166,085,242✔

288

  if (hash == NULL) return terrno;

166,085,242✔

290

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

166,085,242✔

291

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

166,085,242✔

292

  if (pRow == NULL) return terrno;

166,085,242✔

294

  pRow->type = pRaw->type;

166,085,242✔

296

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

166,085,242✔

297

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

166,085,242✔

299

  switch (pRaw->status) {

166,085,242✔

300

    case SDB_STATUS_CREATING:

4,385,425✔

301

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

4,385,425✔

302

      break;

4,385,425✔

303

    case SDB_STATUS_READY:

137,609,710✔

306

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

137,609,710✔

307

      break;

137,609,710✔

308

    case SDB_STATUS_DROPPED:

24,090,107✔

309

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

24,090,107✔

310

      break;

24,090,107✔

313

  return code;

166,085,242✔

316

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

19,114,011✔

317

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

19,114,011✔

318

  sdbFreeRaw(pRaw);

19,114,011✔

319

  return code;

19,114,011✔

322

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

827,629,895✔

323

  terrno = 0;

827,629,895✔

325

  SHashObj *hash = sdbGetHash(pSdb, type);

827,629,915✔

326

  if (hash == NULL) return NULL;

827,623,049✔

328

  void   *pRet = NULL;

827,623,049✔

329

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

827,623,049✔

331

  sdbReadLock(pSdb, type);

827,624,454✔

333

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

827,631,759✔

334

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

827,631,193✔

335

    sdbUnLock(pSdb, type);

181,170,304✔

336

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

181,170,659✔

337

    return NULL;

181,170,659✔

340

  SSdbRow *pRow = *ppRow;

646,461,410✔

341

  switch (pRow->status) {

646,461,410✔

342

    case SDB_STATUS_READY:

644,212,117✔

343

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

644,212,117✔

344

      pRet = pRow->pObj;

644,212,281✔

345

      sdbPrintOper(pSdb, pRow, "acquire");

644,212,218✔

346

      break;

644,211,124✔

347

    case SDB_STATUS_CREATING:

1,844,595✔

348

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

1,844,595✔

349

      break;

1,844,595✔

350

    case SDB_STATUS_DROPPING:

405,081✔

351

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

405,081✔

352

      break;

405,081✔

358

  if (pRet == NULL) {

646,460,800✔

359

    if (!onlyReady) {

2,249,676✔

367

  sdbUnLock(pSdb, type);

646,460,800✔

368

  return pRet;

646,461,526✔

371

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

826,911,409✔

372

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

718,782✔

373

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

718,782✔

376

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

24,080,032✔

377

  int32_t type = pRow->type;

24,080,032✔

378

  sdbWriteLock(pSdb, type);

24,080,032✔

380

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

24,080,032✔

381

  sdbPrintOper(pSdb, pRow, "check");

24,080,032✔

382

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

24,080,032✔

383

    sdbFreeRow(pSdb, pRow, true);

4,659,975✔

386

  sdbUnLock(pSdb, type);

24,080,032✔

387

24,080,032✔

389

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

1,489,911,613✔

390

  if (pObj == NULL) return;

1,489,911,613✔

392

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

1,473,707,180✔

393

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

1,473,708,593✔

395

  int32_t type = pRow->type;

1,473,704,496✔

396

  if (lock) {

1,473,703,475✔

397

    sdbWriteLock(pSdb, type);

1,472,488,602✔

400

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

1,473,716,360✔

401

  sdbPrintOper(pSdb, pRow, "release");

1,473,719,324✔

402

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

1,473,713,284✔

403

    sdbFreeRow(pSdb, pRow, true);

19,420,057✔

405

  if (ref < 0) {

1,473,713,876✔

406

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

7,490,202✔

409

  if (lock) {

1,473,711,581✔

410

    sdbUnLock(pSdb, type);

1,472,494,540✔

414

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

1,488,696,270✔

416

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

852,676,153✔

417

  *ppObj = NULL;

852,676,153✔

419

  SHashObj *hash = sdbGetHash(pSdb, type);

852,676,787✔

420

  if (hash == NULL) return NULL;

852,671,918✔

422

  sdbReadLock(pSdb, type);

852,671,918✔

424

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

852,677,052✔

425

  while (ppRow != NULL) {

860,278,704✔

426

    SSdbRow *pRow = *ppRow;

629,046,809✔

427

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

629,048,137✔

428

      ppRow = taosHashIterate(hash, ppRow);

7,603,771✔

429

      continue;

7,598,162✔

432

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

621,444,366✔

434

    sdbPrintOper(pSdb, pRow, "fetch");

621,449,985✔

435

    *ppObj = pRow->pObj;

621,436,506✔

436

    break;

621,438,560✔

438

  sdbUnLock(pSdb, type);

852,670,455✔

440

  return ppRow;

852,683,081✔

443

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

282,470,285✔

444

  *ppObj = NULL;

282,470,285✔

446

  SHashObj *hash = sdbGetHash(pSdb, type);

282,470,285✔

447

  if (hash == NULL) return NULL;

282,470,285✔

449

  if (lock) {

282,470,285✔

450

    sdbReadLock(pSdb, type);

280,451,678✔

453

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

282,470,285✔

454

  while (ppRow != NULL) {

282,470,285✔

455

    SSdbRow *pRow = *ppRow;

208,032,974✔

456

    if (pRow == NULL) {

208,032,974✔

461

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

208,032,974✔

462

    sdbPrintOper(pSdb, pRow, "fetch");

208,032,974✔

463

    *ppObj = pRow->pObj;

208,032,974✔

464

    *status = pRow->status;

208,032,974✔

465

    break;

208,032,974✔

467

  if (lock) {

282,470,285✔

468

    sdbUnLock(pSdb, type);

280,451,678✔

471

  return ppRow;

282,470,285✔

474

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

103,566,353✔

475

  if (pIter == NULL) return;

103,566,353✔

476

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

92,263,274✔

477

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

92,263,274✔

478

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

92,263,274✔

479

  if (hash == NULL) return;

92,263,274✔

481

  int32_t type = pRow->type;

92,263,274✔

482

  sdbReadLock(pSdb, type);

92,263,274✔

483

  taosHashCancelIterate(hash, pIter);

92,263,274✔

484

  sdbUnLock(pSdb, type);

92,263,274✔

487

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

113✔

488

  if (pIter == NULL) return;

113✔

489

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

113✔

490

  SHashObj *hash = sdbGetHash(pSdb, type);

113✔

491

  if (hash == NULL) return;

113✔

493

  sdbReadLock(pSdb, type);

113✔

494

  taosHashCancelIterate(hash, pIter);

113✔

495

  sdbUnLock(pSdb, type);

113✔

498

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

10,706,553✔

499

  SHashObj *hash = sdbGetHash(pSdb, type);

10,706,553✔

500

  if (hash == NULL) return;

10,706,553✔

502

  sdbReadLock(pSdb, type);

10,706,553✔

504

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

10,706,553✔

505

  while (ppRow != NULL) {

44,830,251✔

506

    SSdbRow *pRow = *ppRow;

34,138,553✔

507

    if (pRow->status == SDB_STATUS_READY) {

34,138,553✔

508

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

32,164,633✔

509

      if (!isContinue) {

32,164,633✔

510

        taosHashCancelIterate(hash, ppRow);

14,855✔

511

        break;

14,855✔

515

    ppRow = taosHashIterate(hash, ppRow);

34,123,698✔

518

  sdbUnLock(pSdb, type);

10,706,553✔

521

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

198,787,869✔

522

  SHashObj *hash = sdbGetHash(pSdb, type);

198,787,869✔

523

  if (hash == NULL) return 0;

198,786,744✔

525

  sdbReadLock(pSdb, type);

198,786,744✔

526

  int32_t size = taosHashGetSize(hash);

198,787,455✔

527

  sdbUnLock(pSdb, type);

198,785,503✔

529

  return size;

198,786,849✔

532

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

20,516,870✔

533

  SHashObj *hash = sdbGetHash(pSdb, type);

20,516,870✔

534

  if (hash == NULL) return -1;

20,516,870✔

536

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

20,516,870✔

538

  int32_t maxId = 0;

20,516,870✔

539

  sdbReadLock(pSdb, type);

20,516,870✔

541

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

20,516,870✔

542

  while (ppRow != NULL) {

33,933,530✔

543

    SSdbRow *pRow = *ppRow;

13,416,660✔

544

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

13,416,660✔

545

    maxId = TMAX(id, maxId);

13,416,660✔

546

    ppRow = taosHashIterate(hash, ppRow);

13,416,660✔

549

  sdbUnLock(pSdb, type);

20,516,870✔

550

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

20,516,870✔

551

  return maxId + 1;

20,516,870✔

554

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

132,626,829✔

555

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

132,626,829✔

560

  return pSdb->tableVer[type];

132,626,829✔

576

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

389,964✔

577

  SHashObj *hash = sdbGetHash(pSdb, type);

389,964✔

578

  if (hash == NULL) return false;

389,964✔

579

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

389,964✔

581

  sdbReadLock(pSdb, type);

389,964✔

582

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

389,964✔

583

  sdbUnLock(pSdb, type);

389,964✔

585

  return (NULL != p);

389,964✔

taosdata / TDengine / #4897

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

taosdata / TDengine / #4897

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