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

21

const char *sdbTableName(ESdbType type) {

405,430,166✔

22

  switch (type) {

405,430,166✔

23

    case SDB_TRANS:

58,613,037✔

24

      return "trans";

58,613,037✔

25

    case SDB_CLUSTER:

3,382,152✔

26

      return "cluster";

3,382,152✔

27

    case SDB_MNODE:

3,223,432✔

28

      return "mnode";

3,223,432✔

29

    case SDB_QNODE:

1,694,011✔

30

      return "qnode";

1,694,011✔

31

    case SDB_SNODE:

1,738,175✔

32

      return "snode";

1,738,175✔

33

    case SDB_DNODE:

6,490,380✔

34

      return "dnode";

6,490,380✔

35

    case SDB_USER:

10,940,635✔

36

      return "user";

10,940,635✔

39

    case SDB_ACCT:

3,048,065✔

40

      return "acct";

3,048,065✔

43

    case SDB_STREAM:

2,073,302✔

44

      return "stream";

2,073,302✔

47

    case SDB_SUBSCRIBE:

2,485,230✔

48

      return "subscribe";

2,485,230✔

49

    case SDB_CONSUMER:

3,248,890✔

50

      return "consumer";

3,248,890✔

51

    case SDB_TOPIC:

2,208,988✔

52

      return "topic";

2,208,988✔

53

    case SDB_VGROUP:

30,070,913✔

54

      return "vgroup";

30,070,913✔

55

    case SDB_SMA:

1,690,000✔

56

      return "sma";

1,690,000✔

57

    case SDB_STB:

40,834,812✔

58

      return "stb";

40,834,812✔

59

    case SDB_DB:

23,682,489✔

60

      return "db";

23,682,489✔

61

    case SDB_FUNC:

1,788,079✔

62

      return "func";

1,788,079✔

63

    case SDB_IDX:

10,591,953✔

64

      return "idx";

10,591,953✔

65

    case SDB_VIEW:

2,778,553✔

66

      return "view";

2,778,553✔

69

    case SDB_COMPACT:

1,933,240✔

70

      return "compact";

1,933,240✔

71

    case SDB_COMPACT_DETAIL:

2,586,784✔

72

      return "compact_detail";

2,586,784✔

73

    case SDB_GRANT:

3,669,579✔

74

      return "grant";

3,669,579✔

75

    case SDB_ARBGROUP:

1,772,743✔

76

      return "arb_group";

1,772,743✔

77

    case SDB_ANODE:

1,690,000✔

78

      return "anode";

1,690,000✔

79

    case SDB_BNODE:

1,690,000✔

80

      return "bnode";

1,690,000✔

81

    case SDB_XNODE:

1,690,606✔

82

      return "xnode";

1,690,606✔

83

    case SDB_CFG:

130,792,896✔

84

      return "config";

130,792,896✔

85

    case SDB_MOUNT:

1,690,000✔

86

      return "mount";

1,690,000✔

87

    case SDB_MOUNT_LOG:

1,690,000✔

88

      return "mount_log";

1,690,000✔

89

    case SDB_SSMIGRATE:

1,788,748✔

90

      return "ssmigrate";

1,788,748✔

91

    case SDB_SCAN:

1,690,000✔

92

      return "scan";

1,690,000✔

93

    case SDB_SCAN_DETAIL:

1,690,000✔

94

      return "scan_detail";

1,690,000✔

95

    case SDB_RSMA:

1,958,392✔

96

      return "rsma";

1,958,392✔

97

    case SDB_RETENTION:

1,788,892✔

98

      return "retention";

1,788,892✔

99

    case SDB_RETENTION_DETAIL:

1,941,952✔

100

      return "retention_detail";

1,941,952✔

101

    case SDB_INSTANCE:

902,206✔

102

      return "instance";

902,206✔

103

    case SDB_ENCRYPT_ALGORITHMS:

10,828,522✔

104

      return "encrypt_algr";

10,828,522✔

105

    case SDB_TOKEN:

1,695,760✔

106

      return "token";

1,695,760✔

107

    case SDB_ROLE:

8,816,890✔

108

      return "role";

8,816,890✔

109

    case SDB_XNODE_TASK:

1,690,202✔

110

      return "xnode_task";

1,690,202✔

111

    case SDB_XNODE_AGENT:

1,690,000✔

112

      return "xnode_agent";

1,690,000✔

113

    case SDB_XNODE_JOB:

1,690,202✔

114

      return "xnode_job";

1,690,202✔

115

    case SDB_XNODE_USER_PASS:

1,690,000✔

116

      return "xnode_user_pass";

1,690,000✔

117

    case SDB_SECURITY_POLICY:

4,089,254✔

118

      return "security_policy";

4,089,254✔

119

    case SDB_GRANT_CLS:

1,690,000✔

120

      return "grant_cls";

1,690,000✔

121

    default:

202✔

122

      return "undefine";

202✔

126

const char *sdbStatusName(ESdbStatus status) {

168,117,746✔

127

  switch (status) {

168,117,746✔

128

    case SDB_STATUS_CREATING:

8,145,041✔

129

      return "creating";

8,145,041✔

130

    case SDB_STATUS_DROPPING:

2,463,598✔

131

      return "dropping";

2,463,598✔

132

    case SDB_STATUS_READY:

142,720,018✔

133

      return "ready";

142,720,018✔

134

    case SDB_STATUS_DROPPED:

14,640,592✔

135

      return "dropped";

14,640,592✔

136

    case SDB_STATUS_INIT:

148,396✔

137

      return "init";

148,396✔

140

    default:

101✔

141

      return "undefine";

101✔

145

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

2,147,483,647✔

147

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

2,147,483,647✔

149

  if (keyType == SDB_KEY_BINARY) {

2,147,483,647✔

150

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

1,354,333,781✔

152

  } else if (keyType == SDB_KEY_INT32) {

2,122,803,460✔

153

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

2,031,927,768✔

155

  } else if (keyType == SDB_KEY_INT64) {

90,875,692✔

156

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

90,875,692✔

161

2,147,483,647✔

163

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

2,147,483,647✔

164

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

2,147,483,647✔

165

    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;

101✔

166

    return NULL;

101✔

169

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

2,147,483,647✔

170

  if (hash == NULL) {

2,147,483,647✔

171

    terrno = TSDB_CODE_APP_ERROR;

101✔

172

    return NULL;

101✔

175

  return hash;

2,147,483,647✔

178

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

1,023,723,662✔

179

  int32_t  keySize = 0;

1,023,723,662✔

180

  EKeyType keyType = pSdb->keyTypes[type];

1,023,723,662✔

182

  if (keyType == SDB_KEY_INT32) {

1,023,724,303✔

183

    keySize = sizeof(int32_t);

578,439,311✔

184

  } else if (keyType == SDB_KEY_BINARY) {

445,284,992✔

185

    keySize = strlen(pKey) + 1;

440,736,044✔

187

    keySize = sizeof(int64_t);

4,548,948✔

190

  return keySize;

1,023,724,303✔

193

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

85,483,543✔

194

  int32_t type = pRow->type;

85,483,543✔

195

  sdbWriteLock(pSdb, type);

85,483,543✔

197

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

85,483,543✔

198

  if (pOldRow != NULL) {

85,483,543✔

205

  pRow->refCount = 0;

85,483,543✔

206

  pRow->status = pRaw->status;

85,483,543✔

207

  sdbPrintOper(pSdb, pRow, "insert");

85,483,543✔

209

  int32_t code = 0;

85,483,543✔

210

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

85,483,543✔

216

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

85,483,543✔

217

  if (insertFp != NULL) {

85,483,543✔

218

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

85,483,543✔

219

    if (code != 0) {

85,483,543✔

230

  sdbUnLock(pSdb, type);

85,483,543✔

232

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

85,483,543✔

233

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

25,292,435✔

235

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

85,483,543✔

236

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

717,653✔

238

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

85,483,543✔

240

  return 0;

85,483,543✔

243

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

121,499,149✔

244

  int32_t type = pNewRow->type;

121,499,149✔

245

  sdbWriteLock(pSdb, type);

121,499,149✔

247

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

121,499,149✔

248

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

121,499,149✔

249

    sdbUnLock(pSdb, type);

81,383,974✔

250

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

81,383,974✔

253

  SSdbRow *pOldRow = *ppOldRow;

40,115,175✔

254

  pOldRow->status = pRaw->status;

40,115,175✔

255

  sdbPrintOper(pSdb, pOldRow, "update");

40,115,175✔

257

  int32_t     code = 0;

40,115,175✔

258

  SdbUpdateFp updateFp = pSdb->updateFps[type];

40,115,175✔

259

  if (updateFp != NULL) {

40,115,175✔

260

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

40,115,175✔

262

  sdbUnLock(pSdb, type);

40,115,175✔

265

  sdbFreeRow(pSdb, pNewRow, false);

40,115,175✔

267

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

40,115,175✔

268

  return code;

40,115,175✔

271

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

23,051,489✔

272

  int32_t type = pRow->type;

23,051,489✔

273

  sdbWriteLock(pSdb, type);

23,051,489✔

275

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

23,051,489✔

276

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

23,051,489✔

277

    sdbUnLock(pSdb, type);

10,156✔

278

    sdbFreeRow(pSdb, pRow, false);

10,156✔

279

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

10,156✔

280

    return terrno;

10,156✔

282

  SSdbRow *pOldRow = *ppOldRow;

23,041,333✔

283

  pOldRow->status = pRaw->status;

23,041,333✔

285

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

23,041,333✔

286

  sdbPrintOper(pSdb, pOldRow, "delete");

23,041,333✔

288

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

23,041,333✔

294

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

23,041,333✔

295

  sdbUnLock(pSdb, type);

23,041,333✔

297

  sdbFreeRow(pSdb, pRow, false);

23,041,333✔

299

  sdbCheckRow(pSdb, pOldRow);

23,041,333✔

300

  return 0;

23,041,333✔

303

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

148,650,409✔

304

  if (pRaw->type == SDB_CFG) {

148,650,409✔

305

    mTrace("sdb write cfg");

50,079,200✔

307

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

148,650,409✔

308

  if (hash == NULL) return terrno;

148,650,409✔

310

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

148,650,207✔

311

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

148,650,207✔

312

  if (pRow == NULL) return terrno;

148,650,207✔

314

  pRow->type = pRaw->type;

148,650,207✔

316

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

148,650,207✔

317

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

148,650,207✔

319

  switch (pRaw->status) {

148,650,207✔

320

    case SDB_STATUS_CREATING:

4,099,569✔

321

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

4,099,569✔

322

      break;

4,099,569✔

323

    case SDB_STATUS_READY:

121,499,149✔

326

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

121,499,149✔

327

      break;

121,499,149✔

328

    case SDB_STATUS_DROPPED:

23,051,489✔

329

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

23,051,489✔

330

      break;

23,051,489✔

333

  return code;

148,650,207✔

336

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

17,980,780✔

337

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

17,980,780✔

338

  sdbFreeRaw(pRaw);

17,980,780✔

339

  return code;

17,980,780✔

342

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

874,978,436✔

343

  terrno = 0;

874,978,436✔

345

  SHashObj *hash = sdbGetHash(pSdb, type);

874,982,130✔

346

  if (hash == NULL) return NULL;

874,979,594✔

348

  void   *pRet = NULL;

874,979,594✔

349

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

874,979,594✔

351

  sdbReadLock(pSdb, type);

874,976,230✔

353

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

874,984,196✔

354

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

874,982,939✔

355

    sdbUnLock(pSdb, type);

149,528,431✔

356

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

149,528,831✔

357

    return NULL;

149,528,831✔

360

  SSdbRow *pRow = *ppRow;

725,454,508✔

361

  switch (pRow->status) {

725,453,698✔

362

    case SDB_STATUS_READY:

725,045,907✔

363

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

725,045,907✔

364

      pRet = pRow->pObj;

725,047,986✔

365

      sdbPrintOper(pSdb, pRow, "acquire");

725,047,986✔

366

      break;

725,045,303✔

367

    case SDB_STATUS_CREATING:

100,055✔

368

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

100,055✔

369

      break;

100,055✔

370

    case SDB_STATUS_DROPPING:

307,042✔

371

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

307,042✔

372

      break;

307,042✔

378

  if (pRet == NULL) {

725,452,400✔

379

    if (!onlyReady) {

407,097✔

387

  sdbUnLock(pSdb, type);

725,452,400✔

388

  return pRet;

725,453,504✔

391

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

874,551,238✔

392

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

429,241✔

393

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

429,241✔

396

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

23,041,333✔

397

  int32_t type = pRow->type;

23,041,333✔

398

  sdbWriteLock(pSdb, type);

23,041,333✔

400

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

23,041,333✔

401

  sdbPrintOper(pSdb, pRow, "check");

23,041,333✔

402

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

23,041,333✔

403

    sdbFreeRow(pSdb, pRow, true);

4,726,577✔

406

  sdbUnLock(pSdb, type);

23,041,333✔

407

23,041,333✔

409

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

1,537,705,405✔

410

  if (pObj == NULL) return;

1,537,705,405✔

412

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

1,519,959,143✔

413

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

1,519,961,801✔

415

  int32_t type = pRow->type;

1,519,966,422✔

416

  if (lock) {

1,519,962,982✔

417

    sdbWriteLock(pSdb, type);

1,519,474,378✔

420

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

1,519,990,371✔

421

  sdbPrintOper(pSdb, pRow, "release");

1,519,999,748✔

422

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

1,519,984,661✔

423

    sdbFreeRow(pSdb, pRow, true);

18,314,756✔

425

  if (ref < 0) {

1,519,984,661✔

426

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

7,467,753✔

429

  if (lock) {

1,519,980,931✔

430

    sdbUnLock(pSdb, type);

1,519,491,708✔

434

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

1,537,218,076✔

436

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

895,529,685✔

437

  *ppObj = NULL;

895,529,685✔

439

  SHashObj *hash = sdbGetHash(pSdb, type);

895,529,950✔

440

  if (hash == NULL) return NULL;

895,530,445✔

442

  sdbReadLock(pSdb, type);

895,530,445✔

444

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

895,535,887✔

445

  while (ppRow != NULL) {

898,236,985✔

446

    SSdbRow *pRow = *ppRow;

645,305,163✔

447

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

645,306,603✔

448

      ppRow = taosHashIterate(hash, ppRow);

2,704,907✔

449

      continue;

2,697,996✔

452

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

642,600,106✔

454

    sdbPrintOper(pSdb, pRow, "fetch");

642,600,937✔

455

    *ppObj = pRow->pObj;

642,597,003✔

456

    break;

642,601,170✔

458

  sdbUnLock(pSdb, type);

895,532,992✔

460

  return ppRow;

895,539,141✔

463

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

209,925,553✔

464

  *ppObj = NULL;

209,925,553✔

466

  SHashObj *hash = sdbGetHash(pSdb, type);

209,925,553✔

467

  if (hash == NULL) return NULL;

209,925,553✔

469

  if (lock) {

209,925,553✔

470

    sdbReadLock(pSdb, type);

208,997,747✔

473

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

209,925,553✔

474

  while (ppRow != NULL) {

209,925,553✔

475

    SSdbRow *pRow = *ppRow;

152,323,949✔

476

    if (pRow == NULL) {

152,323,949✔

481

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

152,323,949✔

482

    sdbPrintOper(pSdb, pRow, "fetch");

152,323,949✔

483

    *ppObj = pRow->pObj;

152,323,949✔

484

    *status = pRow->status;

152,323,949✔

485

    break;

152,323,949✔

487

  if (lock) {

209,925,553✔

488

    sdbUnLock(pSdb, type);

208,997,747✔

491

  return ppRow;

209,925,553✔

494

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

110,629,664✔

495

  if (pIter == NULL) return;

110,629,664✔

496

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

99,106,543✔

497

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

99,106,543✔

498

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

99,106,543✔

499

  if (hash == NULL) return;

99,106,543✔

501

  int32_t type = pRow->type;

99,106,543✔

502

  sdbReadLock(pSdb, type);

99,106,543✔

503

  taosHashCancelIterate(hash, pIter);

99,106,543✔

504

  sdbUnLock(pSdb, type);

99,106,543✔

518

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

9,325,861✔

519

  SHashObj *hash = sdbGetHash(pSdb, type);

9,325,861✔

520

  if (hash == NULL) return;

9,325,861✔

522

  sdbReadLock(pSdb, type);

9,325,861✔

524

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

9,325,861✔

525

  while (ppRow != NULL) {

35,617,015✔

526

    SSdbRow *pRow = *ppRow;

26,291,356✔

527

    if (pRow->status == SDB_STATUS_READY) {

26,291,356✔

528

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

26,291,356✔

529

      if (!isContinue) {

26,291,356✔

530

        taosHashCancelIterate(hash, ppRow);

202✔

531

        break;

202✔

535

    ppRow = taosHashIterate(hash, ppRow);

26,291,154✔

538

  sdbUnLock(pSdb, type);

9,325,861✔

541

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

193,504,546✔

542

  SHashObj *hash = sdbGetHash(pSdb, type);

193,504,546✔

543

  if (hash == NULL) return 0;

193,503,914✔

545

  sdbReadLock(pSdb, type);

193,503,914✔

546

  int32_t size = taosHashGetSize(hash);

193,501,821✔

547

  sdbUnLock(pSdb, type);

193,504,384✔

549

  return size;

193,505,016✔

552

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

21,945,299✔

553

  SHashObj *hash = sdbGetHash(pSdb, type);

21,945,299✔

554

  if (hash == NULL) return -1;

21,945,299✔

556

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

21,945,299✔

558

  int32_t maxId = 0;

21,944,693✔

559

  sdbReadLock(pSdb, type);

21,944,693✔

561

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

21,944,693✔

562

  while (ppRow != NULL) {

36,236,604✔

563

    SSdbRow *pRow = *ppRow;

14,291,911✔

564

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

14,291,911✔

565

    maxId = TMAX(id, maxId);

14,291,911✔

566

    ppRow = taosHashIterate(hash, ppRow);

14,291,911✔

569

  sdbUnLock(pSdb, type);

21,944,693✔

570

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

21,944,693✔

571

  return maxId + 1;

21,944,693✔

574

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

111,318,554✔

575

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

111,318,554✔

576

    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;

101✔

577

    return -1;

101✔

580

  return pSdb->tableVer[type];

111,318,453✔

596

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

93,861✔

597

  SHashObj *hash = sdbGetHash(pSdb, type);

93,861✔

598

  if (hash == NULL) return false;

93,861✔

599

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

93,861✔

601

  sdbReadLock(pSdb, type);

93,861✔

602

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

93,861✔

603

  sdbUnLock(pSdb, type);

93,861✔

605

  return (NULL != p);

93,861✔

taosdata / TDengine / #5071

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) {	405,430,166✔
22	switch (type) {	405,430,166✔
23	case SDB_TRANS:	58,613,037✔
24	return "trans";	58,613,037✔
25	case SDB_CLUSTER:	3,382,152✔
26	return "cluster";	3,382,152✔
27	case SDB_MNODE:	3,223,432✔
28	return "mnode";	3,223,432✔
29	case SDB_QNODE:	1,694,011✔
30	return "qnode";	1,694,011✔
31	case SDB_SNODE:	1,738,175✔
32	return "snode";	1,738,175✔
33	case SDB_DNODE:	6,490,380✔
34	return "dnode";	6,490,380✔
35	case SDB_USER:	10,940,635✔
36	return "user";	10,940,635✔
37	case SDB_AUTH:	×
38	return "auth";	×
39	case SDB_ACCT:	3,048,065✔
40	return "acct";	3,048,065✔
41	case SDB_STREAM_CK:	×
42	return "stream_ck";	×
43	case SDB_STREAM:	2,073,302✔
44	return "stream";	2,073,302✔
45	case SDB_OFFSET:	×
46	return "offset";	×
47	case SDB_SUBSCRIBE:	2,485,230✔
48	return "subscribe";	2,485,230✔
49	case SDB_CONSUMER:	3,248,890✔
50	return "consumer";	3,248,890✔
51	case SDB_TOPIC:	2,208,988✔
52	return "topic";	2,208,988✔
53	case SDB_VGROUP:	30,070,913✔
54	return "vgroup";	30,070,913✔
55	case SDB_SMA:	1,690,000✔
56	return "sma";	1,690,000✔
57	case SDB_STB:	40,834,812✔
58	return "stb";	40,834,812✔
59	case SDB_DB:	23,682,489✔
60	return "db";	23,682,489✔
61	case SDB_FUNC:	1,788,079✔
62	return "func";	1,788,079✔
63	case SDB_IDX:	10,591,953✔
64	return "idx";	10,591,953✔
65	case SDB_VIEW:	2,778,553✔
66	return "view";	2,778,553✔
67	case SDB_STREAM_SEQ:	×
68	return "stream_seq";	×
69	case SDB_COMPACT:	1,933,240✔
70	return "compact";	1,933,240✔
71	case SDB_COMPACT_DETAIL:	2,586,784✔
72	return "compact_detail";	2,586,784✔
73	case SDB_GRANT:	3,669,579✔
74	return "grant";	3,669,579✔
75	case SDB_ARBGROUP:	1,772,743✔
76	return "arb_group";	1,772,743✔
77	case SDB_ANODE:	1,690,000✔
78	return "anode";	1,690,000✔
79	case SDB_BNODE:	1,690,000✔
80	return "bnode";	1,690,000✔
81	case SDB_XNODE:	1,690,606✔
82	return "xnode";	1,690,606✔
83	case SDB_CFG:	130,792,896✔
84	return "config";	130,792,896✔
85	case SDB_MOUNT:	1,690,000✔
86	return "mount";	1,690,000✔
87	case SDB_MOUNT_LOG:	1,690,000✔
88	return "mount_log";	1,690,000✔
89	case SDB_SSMIGRATE:	1,788,748✔
90	return "ssmigrate";	1,788,748✔
91	case SDB_SCAN:	1,690,000✔
92	return "scan";	1,690,000✔
93	case SDB_SCAN_DETAIL:	1,690,000✔
94	return "scan_detail";	1,690,000✔
95	case SDB_RSMA:	1,958,392✔
96	return "rsma";	1,958,392✔
97	case SDB_RETENTION:	1,788,892✔
98	return "retention";	1,788,892✔
99	case SDB_RETENTION_DETAIL:	1,941,952✔
100	return "retention_detail";	1,941,952✔
101	case SDB_INSTANCE:	902,206✔
102	return "instance";	902,206✔
103	case SDB_ENCRYPT_ALGORITHMS:	10,828,522✔
104	return "encrypt_algr";	10,828,522✔
105	case SDB_TOKEN:	1,695,760✔
106	return "token";	1,695,760✔
107	case SDB_ROLE:	8,816,890✔
108	return "role";	8,816,890✔
109	case SDB_XNODE_TASK:	1,690,202✔
110	return "xnode_task";	1,690,202✔
111	case SDB_XNODE_AGENT:	1,690,000✔
112	return "xnode_agent";	1,690,000✔
113	case SDB_XNODE_JOB:	1,690,202✔
114	return "xnode_job";	1,690,202✔
115	case SDB_XNODE_USER_PASS:	1,690,000✔
116	return "xnode_user_pass";	1,690,000✔
117	case SDB_SECURITY_POLICY:	4,089,254✔
118	return "security_policy";	4,089,254✔
119	case SDB_GRANT_CLS:	1,690,000✔
120	return "grant_cls";	1,690,000✔
121	default:	202✔
122	return "undefine";	202✔
123	}
124	}
125
126	const char *sdbStatusName(ESdbStatus status) {	168,117,746✔
127	switch (status) {	168,117,746✔
128	case SDB_STATUS_CREATING:	8,145,041✔
129	return "creating";	8,145,041✔
130	case SDB_STATUS_DROPPING:	2,463,598✔
131	return "dropping";	2,463,598✔
132	case SDB_STATUS_READY:	142,720,018✔
133	return "ready";	142,720,018✔
134	case SDB_STATUS_DROPPED:	14,640,592✔
135	return "dropped";	14,640,592✔
136	case SDB_STATUS_INIT:	148,396✔
137	return "init";	148,396✔
138	case SDB_STATUS_UPDATE:	×
139	return "update";	×
140	default:	101✔
141	return "undefine";	101✔
142	}
143	}
144
145	void sdbPrintOper(SSdb pSdb, SSdbRow pRow, const char *oper) {	2,147,483,647✔
146	#if 1
147	EKeyType keyType = pSdb->keyTypes[pRow->type];	2,147,483,647✔
148
149	if (keyType == SDB_KEY_BINARY) {	2,147,483,647✔
150	mTrace("%s:%s, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj,	1,354,333,781✔
151	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
152	} else if (keyType == SDB_KEY_INT32) {	2,122,803,460✔
153	mTrace("%s:%d, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (int32_t )pRow->pObj,	2,031,927,768✔
154	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
155	} else if (keyType == SDB_KEY_INT64) {	90,875,692✔
156	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	90,875,692✔
157	(int64_t )pRow->pObj, pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
158	} else {
159	}
160	#endif
161	}	2,147,483,647✔
162
163	static SHashObj sdbGetHash(SSdb pSdb, int32_t type) {	2,147,483,647✔
164	if (type >= SDB_MAX \|\| type < 0) {	2,147,483,647✔
165	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	101✔
166	return NULL;	101✔
167	}
168
169	SHashObj *hash = pSdb->hashObjs[type];	2,147,483,647✔
170	if (hash == NULL) {	2,147,483,647✔
171	terrno = TSDB_CODE_APP_ERROR;	101✔
172	return NULL;	101✔
173	}
174
175	return hash;	2,147,483,647✔
176	}
177
178	static int32_t sdbGetkeySize(SSdb pSdb, ESdbType type, const void pKey) {	1,023,723,662✔
179	int32_t keySize = 0;	1,023,723,662✔
180	EKeyType keyType = pSdb->keyTypes[type];	1,023,723,662✔
181
182	if (keyType == SDB_KEY_INT32) {	1,023,724,303✔
183	keySize = sizeof(int32_t);	578,439,311✔
184	} else if (keyType == SDB_KEY_BINARY) {	445,284,992✔
185	keySize = strlen(pKey) + 1;	440,736,044✔
186	} else {
187	keySize = sizeof(int64_t);	4,548,948✔
188	}
189
190	return keySize;	1,023,724,303✔
191	}
192
193	static int32_t sdbInsertRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	85,483,543✔
194	int32_t type = pRow->type;	85,483,543✔
195	sdbWriteLock(pSdb, type);	85,483,543✔
196
197	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	85,483,543✔
198	if (pOldRow != NULL) {	85,483,543✔
199	sdbUnLock(pSdb, type);	×
200	sdbFreeRow(pSdb, pRow, false);	×
201	terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;	×
202	return terrno;	×
203	}
204
205	pRow->refCount = 0;	85,483,543✔
206	pRow->status = pRaw->status;	85,483,543✔
207	sdbPrintOper(pSdb, pRow, "insert");	85,483,543✔
208
209	int32_t code = 0;	85,483,543✔
210	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	85,483,543✔
211	sdbUnLock(pSdb, type);	×
212	sdbFreeRow(pSdb, pRow, false);	×
213	return code;	×
214	}
215
216	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	85,483,543✔
217	if (insertFp != NULL) {	85,483,543✔
218	code = (*insertFp)(pSdb, pRow->pObj);	85,483,543✔
219	if (code != 0) {	85,483,543✔
220	if (taosHashRemove(hash, pRow->pObj, keySize) != 0) {	×
221	mError("failed to remove row from hash");	×
222	}
223	sdbFreeRow(pSdb, pRow, false);	×
224	sdbUnLock(pSdb, type);	×
225	terrno = code;	×
226	return terrno;	×
227	}
228	}
229
230	sdbUnLock(pSdb, type);	85,483,543✔
231
232	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	85,483,543✔
233	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	25,292,435✔
234	}
235	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	85,483,543✔
236	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	717,653✔
237	}
238	pSdb->tableVer[pRow->type]++;	85,483,543✔
239
240	return 0;	85,483,543✔
241	}
242
243	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	121,499,149✔
244	int32_t type = pNewRow->type;	121,499,149✔
245	sdbWriteLock(pSdb, type);	121,499,149✔
246
247	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	121,499,149✔
248	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	121,499,149✔
249	sdbUnLock(pSdb, type);	81,383,974✔
250	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	81,383,974✔
251	}
252
253	SSdbRow pOldRow = ppOldRow;	40,115,175✔
254	pOldRow->status = pRaw->status;	40,115,175✔
255	sdbPrintOper(pSdb, pOldRow, "update");	40,115,175✔
256
257	int32_t code = 0;	40,115,175✔
258	SdbUpdateFp updateFp = pSdb->updateFps[type];	40,115,175✔
259	if (updateFp != NULL) {	40,115,175✔
260	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	40,115,175✔
261	}
262	sdbUnLock(pSdb, type);	40,115,175✔
263
264	// sdbUnLock(pSdb, type);
265	sdbFreeRow(pSdb, pNewRow, false);	40,115,175✔
266
267	pSdb->tableVer[pOldRow->type]++;	40,115,175✔
268	return code;	40,115,175✔
269	}
270
271	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	23,051,489✔
272	int32_t type = pRow->type;	23,051,489✔
273	sdbWriteLock(pSdb, type);	23,051,489✔
274
275	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	23,051,489✔
276	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	23,051,489✔
277	sdbUnLock(pSdb, type);	10,156✔
278	sdbFreeRow(pSdb, pRow, false);	10,156✔
279	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	10,156✔
280	return terrno;	10,156✔
281	}
282	SSdbRow pOldRow = ppOldRow;	23,041,333✔
283	pOldRow->status = pRaw->status;	23,041,333✔
284
285	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	23,041,333✔
286	sdbPrintOper(pSdb, pOldRow, "delete");	23,041,333✔
287
288	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	23,041,333✔
289	sdbUnLock(pSdb, type);	×
290	sdbFreeRow(pSdb, pRow, false);	×
291	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	×
292	return terrno;	×
293	}
294	pSdb->tableVer[pOldRow->type]++;	23,041,333✔
295	sdbUnLock(pSdb, type);	23,041,333✔
296
297	sdbFreeRow(pSdb, pRow, false);	23,041,333✔
298
299	sdbCheckRow(pSdb, pOldRow);	23,041,333✔
300	return 0;	23,041,333✔
301	}
302
303	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	148,650,409✔
304	if (pRaw->type == SDB_CFG) {	148,650,409✔
305	mTrace("sdb write cfg");	50,079,200✔
306	}
307	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	148,650,409✔
308	if (hash == NULL) return terrno;	148,650,409✔
309
310	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	148,650,207✔
311	SSdbRow pRow = (decodeFp)(pRaw);	148,650,207✔
312	if (pRow == NULL) return terrno;	148,650,207✔
313
314	pRow->type = pRaw->type;	148,650,207✔
315
316	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	148,650,207✔
317	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	148,650,207✔
318
319	switch (pRaw->status) {	148,650,207✔
320	case SDB_STATUS_CREATING:	4,099,569✔
321	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	4,099,569✔
322	break;	4,099,569✔
323	case SDB_STATUS_READY:	121,499,149✔
324	case SDB_STATUS_UPDATE:
325	case SDB_STATUS_DROPPING:
326	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	121,499,149✔
327	break;	121,499,149✔
328	case SDB_STATUS_DROPPED:	23,051,489✔
329	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	23,051,489✔
330	break;	23,051,489✔
331	}
332
333	return code;	148,650,207✔
334	}
335
336	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	17,980,780✔
337	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	17,980,780✔
338	sdbFreeRaw(pRaw);	17,980,780✔
339	return code;	17,980,780✔
340	}
341
342	void sdbAcquireAll(SSdb pSdb, ESdbType type, const void *pKey, bool onlyReady) {	874,978,436✔
343	terrno = 0;	874,978,436✔
344
345	SHashObj *hash = sdbGetHash(pSdb, type);	874,982,130✔
346	if (hash == NULL) return NULL;	874,979,594✔
347
348	void *pRet = NULL;	874,979,594✔
349	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	874,979,594✔
350
351	sdbReadLock(pSdb, type);	874,976,230✔
352
353	SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);	874,984,196✔
354	if (ppRow == NULL \|\| *ppRow == NULL) {	874,982,939✔
355	sdbUnLock(pSdb, type);	149,528,431✔
356	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	149,528,831✔
357	return NULL;	149,528,831✔
358	}
359
360	SSdbRow pRow = ppRow;	725,454,508✔
361	switch (pRow->status) {	725,453,698✔
362	case SDB_STATUS_READY:	725,045,907✔
363	(void)atomic_add_fetch_32(&pRow->refCount, 1);	725,045,907✔
364	pRet = pRow->pObj;	725,047,986✔
365	sdbPrintOper(pSdb, pRow, "acquire");	725,047,986✔
366	break;	725,045,303✔
367	case SDB_STATUS_CREATING:	100,055✔
368	terrno = TSDB_CODE_SDB_OBJ_CREATING;	100,055✔
369	break;	100,055✔
370	case SDB_STATUS_DROPPING:	307,042✔
371	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	307,042✔
372	break;	307,042✔
373	default:	×
374	terrno = TSDB_CODE_APP_ERROR;	×
375	break;	×
376	}
377
378	if (pRet == NULL) {	725,452,400✔
379	if (!onlyReady) {	407,097✔
380	terrno = 0;	×
381	(void)atomic_add_fetch_32(&pRow->refCount, 1);	×
382	pRet = pRow->pObj;	×
383	sdbPrintOper(pSdb, pRow, "acquire");	×
384	}
385	}
386
387	sdbUnLock(pSdb, type);	725,452,400✔
388	return pRet;	725,453,504✔
389	}
390
391	void sdbAcquire(SSdb pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }	874,551,238✔
392	void sdbAcquireNotReadyObj(SSdb pSdb, ESdbType type, const void *pKey) {	429,241✔
393	return sdbAcquireAll(pSdb, type, pKey, false);	429,241✔
394	}
395
396	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	23,041,333✔
397	int32_t type = pRow->type;	23,041,333✔
398	sdbWriteLock(pSdb, type);	23,041,333✔
399
400	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	23,041,333✔
401	sdbPrintOper(pSdb, pRow, "check");	23,041,333✔
402	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	23,041,333✔
403	sdbFreeRow(pSdb, pRow, true);	4,726,577✔
404	}
405
406	sdbUnLock(pSdb, type);	23,041,333✔
407	}	23,041,333✔
408
409	void sdbReleaseLock(SSdb pSdb, void pObj, bool lock) {	1,537,705,405✔
410	if (pObj == NULL) return;	1,537,705,405✔
411
412	SSdbRow pRow = (SSdbRow )((char *)pObj - sizeof(SSdbRow));	1,519,959,143✔
413	if (pRow->type >= SDB_MAX) return;	1,519,961,801✔
414
415	int32_t type = pRow->type;	1,519,966,422✔
416	if (lock) {	1,519,962,982✔
417	sdbWriteLock(pSdb, type);	1,519,474,378✔
418	}
419
420	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	1,519,990,371✔
421	sdbPrintOper(pSdb, pRow, "release");	1,519,999,748✔
422	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	1,519,984,661✔
423	sdbFreeRow(pSdb, pRow, true);	18,314,756✔
424	}
425	if (ref < 0) {	1,519,984,661✔
426	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	7,467,753✔
427	}
428
429	if (lock) {	1,519,980,931✔
430	sdbUnLock(pSdb, type);	1,519,491,708✔
431	}
432	}
433
434	void sdbRelease(SSdb pSdb, void pObj) { sdbReleaseLock(pSdb, pObj, true); }	1,537,218,076✔
435
436	void sdbFetch(SSdb pSdb, ESdbType type, void pIter, void *ppObj) {	895,529,685✔
437	*ppObj = NULL;	895,529,685✔
438
439	SHashObj *hash = sdbGetHash(pSdb, type);	895,529,950✔
440	if (hash == NULL) return NULL;	895,530,445✔
441
442	sdbReadLock(pSdb, type);	895,530,445✔
443
444	SSdbRow **ppRow = taosHashIterate(hash, pIter);	895,535,887✔
445	while (ppRow != NULL) {	898,236,985✔
446	SSdbRow pRow = ppRow;	645,305,163✔
447	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	645,306,603✔
448	ppRow = taosHashIterate(hash, ppRow);	2,704,907✔
449	continue;	2,697,996✔
450	}
451
452	(void) atomic_add_fetch_32(&pRow->refCount, 1);	642,600,106✔
453
454	sdbPrintOper(pSdb, pRow, "fetch");	642,600,937✔
455	*ppObj = pRow->pObj;	642,597,003✔
456	break;	642,601,170✔
457	}
458	sdbUnLock(pSdb, type);	895,532,992✔
459
460	return ppRow;	895,539,141✔
461	}
462
463	void sdbFetchAll(SSdb pSdb, ESdbType type, void pIter, void ppObj, ESdbStatus status, bool lock) {	209,925,553✔
464	*ppObj = NULL;	209,925,553✔
465
466	SHashObj *hash = sdbGetHash(pSdb, type);	209,925,553✔
467	if (hash == NULL) return NULL;	209,925,553✔
468
469	if (lock) {	209,925,553✔
470	sdbReadLock(pSdb, type);	208,997,747✔
471	}
472
473	SSdbRow **ppRow = taosHashIterate(hash, pIter);	209,925,553✔
474	while (ppRow != NULL) {	209,925,553✔
475	SSdbRow pRow = ppRow;	152,323,949✔
476	if (pRow == NULL) {	152,323,949✔
477	ppRow = taosHashIterate(hash, ppRow);	×
478	continue;	×
479	}
480
481	(void)atomic_add_fetch_32(&pRow->refCount, 1);	152,323,949✔
482	sdbPrintOper(pSdb, pRow, "fetch");	152,323,949✔
483	*ppObj = pRow->pObj;	152,323,949✔
484	*status = pRow->status;	152,323,949✔
485	break;	152,323,949✔
486	}
487	if (lock) {	209,925,553✔
488	sdbUnLock(pSdb, type);	208,997,747✔
489	}
490
491	return ppRow;	209,925,553✔
492	}
493
494	void sdbCancelFetch(SSdb pSdb, void pIter) {	110,629,664✔
495	if (pIter == NULL) return;	110,629,664✔
496	SSdbRow pRow = (SSdbRow **)pIter;	99,106,543✔
497	mTrace("cancel fetch row:%p", pRow);	99,106,543✔
498	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	99,106,543✔
499	if (hash == NULL) return;	99,106,543✔
500
501	int32_t type = pRow->type;	99,106,543✔
502	sdbReadLock(pSdb, type);	99,106,543✔
503	taosHashCancelIterate(hash, pIter);	99,106,543✔
504	sdbUnLock(pSdb, type);	99,106,543✔
505	}
506
507	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	×
508	if (pIter == NULL) return;	×
509	if (type >= SDB_MAX \|\| type < 0) return;	×
510	SHashObj *hash = sdbGetHash(pSdb, type);	×
511	if (hash == NULL) return;	×
512
513	sdbReadLock(pSdb, type);	×
514	taosHashCancelIterate(hash, pIter);	×
515	sdbUnLock(pSdb, type);	×
516	}
517
518	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	9,325,861✔
519	SHashObj *hash = sdbGetHash(pSdb, type);	9,325,861✔
520	if (hash == NULL) return;	9,325,861✔
521
522	sdbReadLock(pSdb, type);	9,325,861✔
523
524	SSdbRow **ppRow = taosHashIterate(hash, NULL);	9,325,861✔
525	while (ppRow != NULL) {	35,617,015✔
526	SSdbRow pRow = ppRow;	26,291,356✔
527	if (pRow->status == SDB_STATUS_READY) {	26,291,356✔
528	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	26,291,356✔
529	if (!isContinue) {	26,291,356✔
530	taosHashCancelIterate(hash, ppRow);	202✔
531	break;	202✔
532	}
533	}
534
535	ppRow = taosHashIterate(hash, ppRow);	26,291,154✔
536	}
537
538	sdbUnLock(pSdb, type);	9,325,861✔
539	}
540
541	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	193,504,546✔
542	SHashObj *hash = sdbGetHash(pSdb, type);	193,504,546✔
543	if (hash == NULL) return 0;	193,503,914✔
544
545	sdbReadLock(pSdb, type);	193,503,914✔
546	int32_t size = taosHashGetSize(hash);	193,501,821✔
547	sdbUnLock(pSdb, type);	193,504,384✔
548
549	return size;	193,505,016✔
550	}
551
552	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	21,945,299✔
553	SHashObj *hash = sdbGetHash(pSdb, type);	21,945,299✔
554	if (hash == NULL) return -1;	21,945,299✔
555
556	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	21,945,299✔
557
558	int32_t maxId = 0;	21,944,693✔
559	sdbReadLock(pSdb, type);	21,944,693✔
560
561	SSdbRow **ppRow = taosHashIterate(hash, NULL);	21,944,693✔
562	while (ppRow != NULL) {	36,236,604✔
563	SSdbRow pRow = ppRow;	14,291,911✔
564	int32_t id = (int32_t )pRow->pObj;	14,291,911✔
565	maxId = TMAX(id, maxId);	14,291,911✔
566	ppRow = taosHashIterate(hash, ppRow);	14,291,911✔
567	}
568
569	sdbUnLock(pSdb, type);	21,944,693✔
570	maxId = TMAX(maxId, pSdb->maxId[type]);	21,944,693✔
571	return maxId + 1;	21,944,693✔
572	}
573
574	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	111,318,554✔
575	if (type >= SDB_MAX \|\| type < 0) {	111,318,554✔
576	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	101✔
577	return -1;	101✔
578	}
579
580	return pSdb->tableVer[type];	111,318,453✔
581	}
582
583	bool countValid(SMnode pMnode, void pObj, void p1, void p2, void *p3) {	×
584	int32_t *pInt = p1;	×
585	(*pInt) += 1;	×
586	return true;	×
587	}
588
589	int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {	×
590	int32_t num = 0;	×
591	sdbTraverse(pSdb, type, countValid, &num, 0, 0);	×
592	return num;	×
593	}
594
595
596	bool sdbCheckExists(SSdb pSdb, ESdbType type, const void pKey) {	93,861✔
597	SHashObj *hash = sdbGetHash(pSdb, type);	93,861✔
598	if (hash == NULL) return false;	93,861✔
599	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	93,861✔
600
601	sdbReadLock(pSdb, type);	93,861✔
602	void* p = taosHashGet(hash, pKey, keySize);	93,861✔
603	sdbUnLock(pSdb, type);	93,861✔
604
605	return (NULL != p);	93,861✔
606	}
607
608

taosdata / TDengine / #5071

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