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

21

const char *sdbTableName(ESdbType type) {

389,944,203✔

22

  switch (type) {

389,944,203✔

23

    case SDB_TRANS:

62,427,109✔

24

      return "trans";

62,427,109✔

25

    case SDB_CLUSTER:

3,672,447✔

26

      return "cluster";

3,672,447✔

27

    case SDB_MNODE:

4,133,835✔

28

      return "mnode";

4,133,835✔

29

    case SDB_QNODE:

2,185,403✔

30

      return "qnode";

2,185,403✔

31

    case SDB_SNODE:

4,299,499✔

32

      return "snode";

4,299,499✔

33

    case SDB_DNODE:

7,847,955✔

34

      return "dnode";

7,847,955✔

35

    case SDB_USER:

7,789,692✔

36

      return "user";

7,789,692✔

37

    case SDB_AUTH:

1,528✔

38

      return "auth";

1,528✔

39

    case SDB_ACCT:

3,519,783✔

40

      return "acct";

3,519,783✔

41

    case SDB_STREAM_CK:

1,528✔

42

      return "stream_ck";

1,528✔

43

    case SDB_STREAM:

2,713,648✔

44

      return "stream";

2,713,648✔

45

    case SDB_OFFSET:

1,528✔

46

      return "offset";

1,528✔

47

    case SDB_SUBSCRIBE:

2,372,166✔

48

      return "subscribe";

2,372,166✔

49

    case SDB_CONSUMER:

2,711,674✔

50

      return "consumer";

2,711,674✔

51

    case SDB_TOPIC:

2,283,266✔

52

      return "topic";

2,283,266✔

53

    case SDB_VGROUP:

32,043,357✔

54

      return "vgroup";

32,043,357✔

55

    case SDB_SMA:

2,042,998✔

56

      return "sma";

2,042,998✔

57

    case SDB_STB:

51,541,135✔

58

      return "stb";

51,541,135✔

59

    case SDB_DB:

18,187,487✔

60

      return "db";

18,187,487✔

61

    case SDB_FUNC:

2,120,374✔

62

      return "func";

2,120,374✔

63

    case SDB_IDX:

12,979,317✔

64

      return "idx";

12,979,317✔

65

    case SDB_VIEW:

3,257,953✔

66

      return "view";

3,257,953✔

67

    case SDB_STREAM_SEQ:

1,528✔

68

      return "stream_seq";

1,528✔

69

    case SDB_COMPACT:

2,279,359✔

70

      return "compact";

2,279,359✔

71

    case SDB_COMPACT_DETAIL:

3,180,349✔

72

      return "compact_detail";

3,180,349✔

73

    case SDB_GRANT:

4,182,338✔

74

      return "grant";

4,182,338✔

75

    case SDB_ARBGROUP:

2,116,530✔

76

      return "arb_group";

2,116,530✔

77

    case SDB_ANODE:

2,042,998✔

78

      return "anode";

2,042,998✔

79

    case SDB_BNODE:

2,504,205✔

80

      return "bnode";

2,504,205✔

81

    case SDB_CFG:

127,108,978✔

82

      return "config";

127,108,978✔

83

    case SDB_MOUNT:

2,051,238✔

84

      return "mount";

2,051,238✔

85

    case SDB_MOUNT_LOG:

2,047,749✔

86

      return "mount_log";

2,047,749✔

87

    case SDB_SSMIGRATE:

2,042,998✔

88

      return "ssmigrate";

2,042,998✔

89

    case SDB_SCAN:

2,046,376✔

90

      return "scan";

2,046,376✔

91

    case SDB_SCAN_DETAIL:

2,048,056✔

92

      return "scan_detail";

2,048,056✔

93

    case SDB_RSMA:

2,333,302✔

94

      return "rsma";

2,333,302✔

95

    case SDB_INSTANCE:

1,186,152✔

96

      return "instance";

1,186,152✔

97

    default:

4,638,365✔

98

      return "undefine";

4,638,365✔

102

const char *sdbStatusName(ESdbStatus status) {

159,653,430✔

103

  switch (status) {

159,653,430✔

104

    case SDB_STATUS_CREATING:

8,379,931✔

105

      return "creating";

8,379,931✔

106

    case SDB_STATUS_DROPPING:

2,715,935✔

107

      return "dropping";

2,715,935✔

108

    case SDB_STATUS_READY:

133,907,779✔

109

      return "ready";

133,907,779✔

110

    case SDB_STATUS_DROPPED:

14,562,652✔

111

      return "dropped";

14,562,652✔

112

    case SDB_STATUS_INIT:

87,133✔

113

      return "init";

87,133✔

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,064,763,896✔

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,147,483,647✔

131

  } else if (keyType == SDB_KEY_INT64) {

105,284,032✔

132

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

105,284,205✔

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

992,322,457✔

155

  int32_t  keySize = 0;

992,322,457✔

156

  EKeyType keyType = pSdb->keyTypes[type];

992,322,457✔

158

  if (keyType == SDB_KEY_INT32) {

992,323,705✔

159

    keySize = sizeof(int32_t);

654,629,922✔

160

  } else if (keyType == SDB_KEY_BINARY) {

337,693,783✔

161

    keySize = strlen(pKey) + 1;

334,941,057✔

163

    keySize = sizeof(int64_t);

2,752,726✔

166

  return keySize;

992,323,705✔

169

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

87,231,572✔

170

  int32_t type = pRow->type;

87,231,572✔

171

  sdbWriteLock(pSdb, type);

87,231,572✔

173

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

87,231,572✔

174

  if (pOldRow != NULL) {

87,231,572✔

181

  pRow->refCount = 0;

87,231,572✔

182

  pRow->status = pRaw->status;

87,231,572✔

183

  sdbPrintOper(pSdb, pRow, "insert");

87,231,572✔

185

  int32_t code = 0;

87,231,572✔

186

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

87,231,572✔

192

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

87,231,572✔

193

  if (insertFp != NULL) {

87,231,572✔

194

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

87,231,572✔

195

    if (code != 0) {

87,231,572✔

206

  sdbUnLock(pSdb, type);

87,231,572✔

208

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

87,231,572✔

209

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

24,085,104✔

211

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

87,231,572✔

212

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

782,179✔

214

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

87,231,572✔

216

  return 0;

87,231,572✔

219

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

128,322,891✔

220

  int32_t type = pNewRow->type;

128,322,891✔

221

  sdbWriteLock(pSdb, type);

128,322,891✔

223

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

128,322,891✔

224

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

128,322,891✔

225

    sdbUnLock(pSdb, type);

82,897,933✔

226

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

82,897,933✔

229

  SSdbRow *pOldRow = *ppOldRow;

45,424,958✔

230

  pOldRow->status = pRaw->status;

45,424,958✔

231

  sdbPrintOper(pSdb, pOldRow, "update");

45,424,958✔

233

  int32_t     code = 0;

45,424,958✔

234

  SdbUpdateFp updateFp = pSdb->updateFps[type];

45,424,958✔

235

  if (updateFp != NULL) {

45,424,958✔

236

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

45,424,958✔

238

  sdbUnLock(pSdb, type);

45,424,958✔

241

  sdbFreeRow(pSdb, pNewRow, false);

45,424,958✔

243

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

45,424,958✔

244

  return code;

45,424,958✔

247

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

23,860,209✔

248

  int32_t type = pRow->type;

23,860,209✔

249

  sdbWriteLock(pSdb, type);

23,860,209✔

251

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

23,860,209✔

252

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

23,860,209✔

253

    sdbUnLock(pSdb, type);

13,559✔

254

    sdbFreeRow(pSdb, pRow, false);

13,559✔

255

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

13,559✔

256

    return terrno;

13,559✔

258

  SSdbRow *pOldRow = *ppOldRow;

23,846,650✔

259

  pOldRow->status = pRaw->status;

23,846,650✔

261

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

23,846,650✔

262

  sdbPrintOper(pSdb, pOldRow, "delete");

23,846,650✔

264

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

23,846,650✔

270

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

23,846,650✔

271

  sdbUnLock(pSdb, type);

23,846,650✔

273

  sdbFreeRow(pSdb, pRow, false);

23,846,650✔

275

  sdbCheckRow(pSdb, pOldRow);

23,846,650✔

276

  return 0;

23,846,650✔

279

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

156,516,739✔

280

  if (pRaw->type == SDB_CFG) {

156,516,739✔

281

    mTrace("sdb write cfg");

52,348,254✔

283

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

156,516,739✔

284

  if (hash == NULL) return terrno;

156,516,739✔

286

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

156,516,739✔

287

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

156,516,739✔

288

  if (pRow == NULL) return terrno;

156,516,739✔

290

  pRow->type = pRaw->type;

156,516,739✔

292

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

156,516,739✔

293

  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;

156,516,739✔

295

  switch (pRaw->status) {

156,516,739✔

296

    case SDB_STATUS_CREATING:

4,333,639✔

297

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

4,333,639✔

298

      break;

4,333,639✔

299

    case SDB_STATUS_READY:

128,322,891✔

302

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

128,322,891✔

303

      break;

128,322,891✔

304

    case SDB_STATUS_DROPPED:

23,860,209✔

305

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

23,860,209✔

306

      break;

23,860,209✔

309

  return code;

156,516,739✔

312

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

18,844,645✔

313

  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);

18,844,645✔

314

  sdbFreeRaw(pRaw);

18,844,645✔

315

  return code;

18,844,645✔

318

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

835,367,253✔

319

  terrno = 0;

835,367,253✔

321

  SHashObj *hash = sdbGetHash(pSdb, type);

835,367,164✔

322

  if (hash == NULL) return NULL;

835,363,430✔

324

  void   *pRet = NULL;

835,363,430✔

325

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

835,363,430✔

327

  sdbReadLock(pSdb, type);

835,365,426✔

329

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

835,369,154✔

330

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

835,368,894✔

331

    sdbUnLock(pSdb, type);

186,153,738✔

332

    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;

186,154,185✔

333

    return NULL;

186,154,185✔

336

  SSdbRow *pRow = *ppRow;

649,215,260✔

337

  switch (pRow->status) {

649,215,260✔

338

    case SDB_STATUS_READY:

647,066,523✔

339

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

647,066,523✔

340

      pRet = pRow->pObj;

647,066,508✔

341

      sdbPrintOper(pSdb, pRow, "acquire");

647,066,842✔

342

      break;

647,066,153✔

343

    case SDB_STATUS_CREATING:

1,742,663✔

344

      terrno = TSDB_CODE_SDB_OBJ_CREATING;

1,742,663✔

345

      break;

1,742,663✔

346

    case SDB_STATUS_DROPPING:

405,767✔

347

      terrno = TSDB_CODE_SDB_OBJ_DROPPING;

405,767✔

348

      break;

405,767✔

354

  if (pRet == NULL) {

649,214,583✔

355

    if (!onlyReady) {

2,148,430✔

363

  sdbUnLock(pSdb, type);

649,214,583✔

364

  return pRet;

649,214,888✔

367

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

834,695,519✔

368

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

671,387✔

369

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

671,387✔

372

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

23,846,650✔

373

  int32_t type = pRow->type;

23,846,650✔

374

  sdbWriteLock(pSdb, type);

23,846,650✔

376

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

23,846,650✔

377

  sdbPrintOper(pSdb, pRow, "check");

23,846,650✔

378

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

23,846,650✔

379

    sdbFreeRow(pSdb, pRow, true);

4,685,794✔

382

  sdbUnLock(pSdb, type);

23,846,650✔

383

23,846,650✔

385

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

1,453,934,411✔

386

  if (pObj == NULL) return;

1,453,934,411✔

388

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

1,437,752,134✔

389

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

1,437,754,523✔

391

  int32_t type = pRow->type;

1,437,752,306✔

392

  if (lock) {

1,437,751,344✔

393

    sdbWriteLock(pSdb, type);

1,436,635,573✔

396

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

1,437,766,579✔

397

  sdbPrintOper(pSdb, pRow, "release");

1,437,763,490✔

398

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

1,437,759,642✔

399

    sdbFreeRow(pSdb, pRow, true);

19,160,856✔

401

  if (ref < 0) {

1,437,760,374✔

402

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

1,482,082✔

405

  if (lock) {

1,437,759,473✔

406

    sdbUnLock(pSdb, type);

1,436,646,245✔

410

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

1,452,819,776✔

412

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

881,563,840✔

413

  *ppObj = NULL;

881,563,840✔

415

  SHashObj *hash = sdbGetHash(pSdb, type);

881,562,976✔

416

  if (hash == NULL) return NULL;

881,565,249✔

418

  sdbReadLock(pSdb, type);

881,565,249✔

420

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

881,567,959✔

421

  while (ppRow != NULL) {

889,635,828✔

422

    SSdbRow *pRow = *ppRow;

655,345,135✔

423

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

655,345,489✔

424

      ppRow = taosHashIterate(hash, ppRow);

8,070,926✔

425

      continue;

8,068,734✔

428

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

647,274,563✔

430

    sdbPrintOper(pSdb, pRow, "fetch");

647,275,196✔

431

    *ppObj = pRow->pObj;

647,267,571✔

432

    break;

647,270,488✔

434

  sdbUnLock(pSdb, type);

881,561,181✔

436

  return ppRow;

881,568,116✔

439

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

178,524,716✔

440

  *ppObj = NULL;

178,524,716✔

442

  SHashObj *hash = sdbGetHash(pSdb, type);

178,524,716✔

443

  if (hash == NULL) return NULL;

178,524,716✔

445

  if (lock) {

178,524,716✔

446

    sdbReadLock(pSdb, type);

176,655,294✔

449

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

178,524,716✔

450

  while (ppRow != NULL) {

178,524,716✔

451

    SSdbRow *pRow = *ppRow;

143,434,362✔

452

    if (pRow == NULL) {

143,434,362✔

457

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

143,434,362✔

458

    sdbPrintOper(pSdb, pRow, "fetch");

143,434,362✔

459

    *ppObj = pRow->pObj;

143,434,362✔

460

    *status = pRow->status;

143,434,362✔

461

    break;

143,434,362✔

463

  if (lock) {

178,524,716✔

464

    sdbUnLock(pSdb, type);

176,655,294✔

467

  return ppRow;

178,524,716✔

470

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

92,464,662✔

471

  if (pIter == NULL) return;

92,464,662✔

472

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

92,376,184✔

473

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

92,376,184✔

474

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

92,376,184✔

475

  if (hash == NULL) return;

92,376,184✔

477

  int32_t type = pRow->type;

92,376,184✔

478

  sdbReadLock(pSdb, type);

92,376,184✔

479

  taosHashCancelIterate(hash, pIter);

92,376,184✔

480

  sdbUnLock(pSdb, type);

92,376,184✔

483

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

109✔

484

  if (pIter == NULL) return;

109✔

485

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

109✔

486

  SHashObj *hash = sdbGetHash(pSdb, type);

109✔

487

  if (hash == NULL) return;

109✔

489

  sdbReadLock(pSdb, type);

109✔

490

  taosHashCancelIterate(hash, pIter);

109✔

491

  sdbUnLock(pSdb, type);

109✔

494

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

10,565,964✔

495

  SHashObj *hash = sdbGetHash(pSdb, type);

10,565,964✔

496

  if (hash == NULL) return;

10,565,964✔

498

  sdbReadLock(pSdb, type);

10,565,964✔

500

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

10,565,964✔

501

  while (ppRow != NULL) {

44,154,448✔

502

    SSdbRow *pRow = *ppRow;

33,605,114✔

503

    if (pRow->status == SDB_STATUS_READY) {

33,605,114✔

504

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

31,567,634✔

505

      if (!isContinue) {

31,567,634✔

506

        taosHashCancelIterate(hash, ppRow);

16,630✔

507

        break;

16,630✔

511

    ppRow = taosHashIterate(hash, ppRow);

33,588,484✔

514

  sdbUnLock(pSdb, type);

10,565,964✔

517

int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {

194,574,019✔

518

  SHashObj *hash = sdbGetHash(pSdb, type);

194,574,019✔

519

  if (hash == NULL) return 0;

194,572,952✔

521

  sdbReadLock(pSdb, type);

194,572,952✔

522

  int32_t size = taosHashGetSize(hash);

194,571,987✔

523

  sdbUnLock(pSdb, type);

194,571,631✔

525

  return size;

194,573,691✔

528

int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {

20,295,086✔

529

  SHashObj *hash = sdbGetHash(pSdb, type);

20,295,086✔

530

  if (hash == NULL) return -1;

20,295,086✔

532

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

20,295,086✔

534

  int32_t maxId = 0;

20,295,086✔

535

  sdbReadLock(pSdb, type);

20,295,086✔

537

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

20,295,086✔

538

  while (ppRow != NULL) {

34,593,988✔

539

    SSdbRow *pRow = *ppRow;

14,298,902✔

540

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

14,298,902✔

541

    maxId = TMAX(id, maxId);

14,298,902✔

542

    ppRow = taosHashIterate(hash, ppRow);

14,298,902✔

545

  sdbUnLock(pSdb, type);

20,295,086✔

546

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

20,295,086✔

547

  return maxId + 1;

20,295,086✔

550

int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {

134,797,611✔

551

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

134,797,611✔

556

  return pSdb->tableVer[type];

134,797,611✔

572

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

441,965✔

573

  SHashObj *hash = sdbGetHash(pSdb, type);

441,965✔

574

  if (hash == NULL) return false;

441,965✔

575

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

441,965✔

577

  sdbReadLock(pSdb, type);

441,965✔

578

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

441,965✔

579

  sdbUnLock(pSdb, type);

441,965✔

581

  return (NULL != p);

441,965✔

taosdata / TDengine / #4872

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) {	389,944,203✔
22	switch (type) {	389,944,203✔
23	case SDB_TRANS:	62,427,109✔
24	return "trans";	62,427,109✔
25	case SDB_CLUSTER:	3,672,447✔
26	return "cluster";	3,672,447✔
27	case SDB_MNODE:	4,133,835✔
28	return "mnode";	4,133,835✔
29	case SDB_QNODE:	2,185,403✔
30	return "qnode";	2,185,403✔
31	case SDB_SNODE:	4,299,499✔
32	return "snode";	4,299,499✔
33	case SDB_DNODE:	7,847,955✔
34	return "dnode";	7,847,955✔
35	case SDB_USER:	7,789,692✔
36	return "user";	7,789,692✔
37	case SDB_AUTH:	1,528✔
38	return "auth";	1,528✔
39	case SDB_ACCT:	3,519,783✔
40	return "acct";	3,519,783✔
41	case SDB_STREAM_CK:	1,528✔
42	return "stream_ck";	1,528✔
43	case SDB_STREAM:	2,713,648✔
44	return "stream";	2,713,648✔
45	case SDB_OFFSET:	1,528✔
46	return "offset";	1,528✔
47	case SDB_SUBSCRIBE:	2,372,166✔
48	return "subscribe";	2,372,166✔
49	case SDB_CONSUMER:	2,711,674✔
50	return "consumer";	2,711,674✔
51	case SDB_TOPIC:	2,283,266✔
52	return "topic";	2,283,266✔
53	case SDB_VGROUP:	32,043,357✔
54	return "vgroup";	32,043,357✔
55	case SDB_SMA:	2,042,998✔
56	return "sma";	2,042,998✔
57	case SDB_STB:	51,541,135✔
58	return "stb";	51,541,135✔
59	case SDB_DB:	18,187,487✔
60	return "db";	18,187,487✔
61	case SDB_FUNC:	2,120,374✔
62	return "func";	2,120,374✔
63	case SDB_IDX:	12,979,317✔
64	return "idx";	12,979,317✔
65	case SDB_VIEW:	3,257,953✔
66	return "view";	3,257,953✔
67	case SDB_STREAM_SEQ:	1,528✔
68	return "stream_seq";	1,528✔
69	case SDB_COMPACT:	2,279,359✔
70	return "compact";	2,279,359✔
71	case SDB_COMPACT_DETAIL:	3,180,349✔
72	return "compact_detail";	3,180,349✔
73	case SDB_GRANT:	4,182,338✔
74	return "grant";	4,182,338✔
75	case SDB_ARBGROUP:	2,116,530✔
76	return "arb_group";	2,116,530✔
77	case SDB_ANODE:	2,042,998✔
78	return "anode";	2,042,998✔
79	case SDB_BNODE:	2,504,205✔
80	return "bnode";	2,504,205✔
81	case SDB_CFG:	127,108,978✔
82	return "config";	127,108,978✔
83	case SDB_MOUNT:	2,051,238✔
84	return "mount";	2,051,238✔
85	case SDB_MOUNT_LOG:	2,047,749✔
86	return "mount_log";	2,047,749✔
87	case SDB_SSMIGRATE:	2,042,998✔
88	return "ssmigrate";	2,042,998✔
89	case SDB_SCAN:	2,046,376✔
90	return "scan";	2,046,376✔
91	case SDB_SCAN_DETAIL:	2,048,056✔
92	return "scan_detail";	2,048,056✔
93	case SDB_RSMA:	2,333,302✔
94	return "rsma";	2,333,302✔
95	case SDB_INSTANCE:	1,186,152✔
96	return "instance";	1,186,152✔
97	default:	4,638,365✔
98	return "undefine";	4,638,365✔
99	}
100	}
101
102	const char *sdbStatusName(ESdbStatus status) {	159,653,430✔
103	switch (status) {	159,653,430✔
104	case SDB_STATUS_CREATING:	8,379,931✔
105	return "creating";	8,379,931✔
106	case SDB_STATUS_DROPPING:	2,715,935✔
107	return "dropping";	2,715,935✔
108	case SDB_STATUS_READY:	133,907,779✔
109	return "ready";	133,907,779✔
110	case SDB_STATUS_DROPPED:	14,562,652✔
111	return "dropped";	14,562,652✔
112	case SDB_STATUS_INIT:	87,133✔
113	return "init";	87,133✔
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,064,763,896✔
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,147,483,647✔
130	pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
131	} else if (keyType == SDB_KEY_INT64) {	105,284,032✔
132	mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),	105,284,205✔
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) {	992,322,457✔
155	int32_t keySize = 0;	992,322,457✔
156	EKeyType keyType = pSdb->keyTypes[type];	992,322,457✔
157
158	if (keyType == SDB_KEY_INT32) {	992,323,705✔
159	keySize = sizeof(int32_t);	654,629,922✔
160	} else if (keyType == SDB_KEY_BINARY) {	337,693,783✔
161	keySize = strlen(pKey) + 1;	334,941,057✔
162	} else {
163	keySize = sizeof(int64_t);	2,752,726✔
164	}
165
166	return keySize;	992,323,705✔
167	}
168
169	static int32_t sdbInsertRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	87,231,572✔
170	int32_t type = pRow->type;	87,231,572✔
171	sdbWriteLock(pSdb, type);	87,231,572✔
172
173	SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);	87,231,572✔
174	if (pOldRow != NULL) {	87,231,572✔
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;	87,231,572✔
182	pRow->status = pRaw->status;	87,231,572✔
183	sdbPrintOper(pSdb, pRow, "insert");	87,231,572✔
184
185	int32_t code = 0;	87,231,572✔
186	if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {	87,231,572✔
UNCOV 187	sdbUnLock(pSdb, type);	×
UNCOV 188	sdbFreeRow(pSdb, pRow, false);	×
189	return code;	×
190	}
191
192	SdbInsertFp insertFp = pSdb->insertFps[pRow->type];	87,231,572✔
193	if (insertFp != NULL) {	87,231,572✔
194	code = (*insertFp)(pSdb, pRow->pObj);	87,231,572✔
195	if (code != 0) {	87,231,572✔
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);	87,231,572✔
207
208	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {	87,231,572✔
209	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int32_t )pRow->pObj));	24,085,104✔
210	}
211	if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {	87,231,572✔
212	pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], ((int64_t )pRow->pObj));	782,179✔
213	}
214	pSdb->tableVer[pRow->type]++;	87,231,572✔
215
216	return 0;	87,231,572✔
217	}
218
219	static int32_t sdbUpdateRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pNewRow, int32_t keySize) {	128,322,891✔
220	int32_t type = pNewRow->type;	128,322,891✔
221	sdbWriteLock(pSdb, type);	128,322,891✔
222
223	SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);	128,322,891✔
224	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	128,322,891✔
225	sdbUnLock(pSdb, type);	82,897,933✔
226	return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);	82,897,933✔
227	}
228
229	SSdbRow pOldRow = ppOldRow;	45,424,958✔
230	pOldRow->status = pRaw->status;	45,424,958✔
231	sdbPrintOper(pSdb, pOldRow, "update");	45,424,958✔
232
233	int32_t code = 0;	45,424,958✔
234	SdbUpdateFp updateFp = pSdb->updateFps[type];	45,424,958✔
235	if (updateFp != NULL) {	45,424,958✔
236	code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);	45,424,958✔
237	}
238	sdbUnLock(pSdb, type);	45,424,958✔
239
240	// sdbUnLock(pSdb, type);
241	sdbFreeRow(pSdb, pNewRow, false);	45,424,958✔
242
243	pSdb->tableVer[pOldRow->type]++;	45,424,958✔
244	return code;	45,424,958✔
245	}
246
247	static int32_t sdbDeleteRow(SSdb pSdb, SHashObj hash, SSdbRaw pRaw, SSdbRow pRow, int32_t keySize) {	23,860,209✔
248	int32_t type = pRow->type;	23,860,209✔
249	sdbWriteLock(pSdb, type);	23,860,209✔
250
251	SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);	23,860,209✔
252	if (ppOldRow == NULL \|\| *ppOldRow == NULL) {	23,860,209✔
253	sdbUnLock(pSdb, type);	13,559✔
254	sdbFreeRow(pSdb, pRow, false);	13,559✔
255	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	13,559✔
256	return terrno;	13,559✔
257	}
258	SSdbRow pOldRow = ppOldRow;	23,846,650✔
259	pOldRow->status = pRaw->status;	23,846,650✔
260
261	(void)atomic_add_fetch_32(&pOldRow->refCount, 1);	23,846,650✔
262	sdbPrintOper(pSdb, pOldRow, "delete");	23,846,650✔
263
264	if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {	23,846,650✔
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,846,650✔
271	sdbUnLock(pSdb, type);	23,846,650✔
272
273	sdbFreeRow(pSdb, pRow, false);	23,846,650✔
274
275	sdbCheckRow(pSdb, pOldRow);	23,846,650✔
276	return 0;	23,846,650✔
277	}
278
279	int32_t sdbWriteWithoutFree(SSdb pSdb, SSdbRaw pRaw) {	156,516,739✔
280	if (pRaw->type == SDB_CFG) {	156,516,739✔
281	mTrace("sdb write cfg");	52,348,254✔
282	}
283	SHashObj *hash = sdbGetHash(pSdb, pRaw->type);	156,516,739✔
284	if (hash == NULL) return terrno;	156,516,739✔
285
286	SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];	156,516,739✔
287	SSdbRow pRow = (decodeFp)(pRaw);	156,516,739✔
288	if (pRow == NULL) return terrno;	156,516,739✔
289
290	pRow->type = pRaw->type;	156,516,739✔
291
292	int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);	156,516,739✔
293	int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;	156,516,739✔
294
295	switch (pRaw->status) {	156,516,739✔
296	case SDB_STATUS_CREATING:	4,333,639✔
297	code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);	4,333,639✔
298	break;	4,333,639✔
299	case SDB_STATUS_READY:	128,322,891✔
300	case SDB_STATUS_UPDATE:
301	case SDB_STATUS_DROPPING:
302	code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);	128,322,891✔
303	break;	128,322,891✔
304	case SDB_STATUS_DROPPED:	23,860,209✔
305	code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);	23,860,209✔
306	break;	23,860,209✔
307	}
308
309	return code;	156,516,739✔
310	}
311
312	int32_t sdbWrite(SSdb pSdb, SSdbRaw pRaw) {	18,844,645✔
313	int32_t code = sdbWriteWithoutFree(pSdb, pRaw);	18,844,645✔
314	sdbFreeRaw(pRaw);	18,844,645✔
315	return code;	18,844,645✔
316	}
317
318	void sdbAcquireAll(SSdb pSdb, ESdbType type, const void *pKey, bool onlyReady) {	835,367,253✔
319	terrno = 0;	835,367,253✔
320
321	SHashObj *hash = sdbGetHash(pSdb, type);	835,367,164✔
322	if (hash == NULL) return NULL;	835,363,430✔
323
324	void *pRet = NULL;	835,363,430✔
325	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	835,363,430✔
326
327	sdbReadLock(pSdb, type);	835,365,426✔
328
329	SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);	835,369,154✔
330	if (ppRow == NULL \|\| *ppRow == NULL) {	835,368,894✔
331	sdbUnLock(pSdb, type);	186,153,738✔
332	terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;	186,154,185✔
333	return NULL;	186,154,185✔
334	}
335
336	SSdbRow pRow = ppRow;	649,215,260✔
337	switch (pRow->status) {	649,215,260✔
338	case SDB_STATUS_READY:	647,066,523✔
339	(void)atomic_add_fetch_32(&pRow->refCount, 1);	647,066,523✔
340	pRet = pRow->pObj;	647,066,508✔
341	sdbPrintOper(pSdb, pRow, "acquire");	647,066,842✔
342	break;	647,066,153✔
343	case SDB_STATUS_CREATING:	1,742,663✔
344	terrno = TSDB_CODE_SDB_OBJ_CREATING;	1,742,663✔
345	break;	1,742,663✔
346	case SDB_STATUS_DROPPING:	405,767✔
347	terrno = TSDB_CODE_SDB_OBJ_DROPPING;	405,767✔
348	break;	405,767✔
UNCOV 349	default:	×
UNCOV 350	terrno = TSDB_CODE_APP_ERROR;	×
351	break;	×
352	}
353
354	if (pRet == NULL) {	649,214,583✔
355	if (!onlyReady) {	2,148,430✔
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);	649,214,583✔
364	return pRet;	649,214,888✔
365	}
366
367	void sdbAcquire(SSdb pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }	834,695,519✔
368	void sdbAcquireNotReadyObj(SSdb pSdb, ESdbType type, const void *pKey) {	671,387✔
369	return sdbAcquireAll(pSdb, type, pKey, false);	671,387✔
370	}
371
372	static void sdbCheckRow(SSdb pSdb, SSdbRow pRow) {	23,846,650✔
373	int32_t type = pRow->type;	23,846,650✔
374	sdbWriteLock(pSdb, type);	23,846,650✔
375
376	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	23,846,650✔
377	sdbPrintOper(pSdb, pRow, "check");	23,846,650✔
378	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	23,846,650✔
379	sdbFreeRow(pSdb, pRow, true);	4,685,794✔
380	}
381
382	sdbUnLock(pSdb, type);	23,846,650✔
383	}	23,846,650✔
384
385	void sdbReleaseLock(SSdb pSdb, void pObj, bool lock) {	1,453,934,411✔
386	if (pObj == NULL) return;	1,453,934,411✔
387
388	SSdbRow pRow = (SSdbRow )((char *)pObj - sizeof(SSdbRow));	1,437,752,134✔
389	if (pRow->type >= SDB_MAX) return;	1,437,754,523✔
390
391	int32_t type = pRow->type;	1,437,752,306✔
392	if (lock) {	1,437,751,344✔
393	sdbWriteLock(pSdb, type);	1,436,635,573✔
394	}
395
396	int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);	1,437,766,579✔
397	sdbPrintOper(pSdb, pRow, "release");	1,437,763,490✔
398	if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {	1,437,759,642✔
399	sdbFreeRow(pSdb, pRow, true);	19,160,856✔
400	}
401	if (ref < 0) {	1,437,760,374✔
402	mError("row:%p, ref:%d, type:%s", pRow, ref, sdbTableName(type));	1,482,082✔
403	}
404
405	if (lock) {	1,437,759,473✔
406	sdbUnLock(pSdb, type);	1,436,646,245✔
407	}
408	}
409
410	void sdbRelease(SSdb pSdb, void pObj) { sdbReleaseLock(pSdb, pObj, true); }	1,452,819,776✔
411
412	void sdbFetch(SSdb pSdb, ESdbType type, void pIter, void *ppObj) {	881,563,840✔
413	*ppObj = NULL;	881,563,840✔
414
415	SHashObj *hash = sdbGetHash(pSdb, type);	881,562,976✔
416	if (hash == NULL) return NULL;	881,565,249✔
417
418	sdbReadLock(pSdb, type);	881,565,249✔
419
420	SSdbRow **ppRow = taosHashIterate(hash, pIter);	881,567,959✔
421	while (ppRow != NULL) {	889,635,828✔
422	SSdbRow pRow = ppRow;	655,345,135✔
423	if (pRow == NULL \|\| pRow->status != SDB_STATUS_READY) {	655,345,489✔
424	ppRow = taosHashIterate(hash, ppRow);	8,070,926✔
425	continue;	8,068,734✔
426	}
427
428	(void) atomic_add_fetch_32(&pRow->refCount, 1);	647,274,563✔
429
430	sdbPrintOper(pSdb, pRow, "fetch");	647,275,196✔
431	*ppObj = pRow->pObj;	647,267,571✔
432	break;	647,270,488✔
433	}
434	sdbUnLock(pSdb, type);	881,561,181✔
435
436	return ppRow;	881,568,116✔
437	}
438
439	void sdbFetchAll(SSdb pSdb, ESdbType type, void pIter, void ppObj, ESdbStatus status, bool lock) {	178,524,716✔
440	*ppObj = NULL;	178,524,716✔
441
442	SHashObj *hash = sdbGetHash(pSdb, type);	178,524,716✔
443	if (hash == NULL) return NULL;	178,524,716✔
444
445	if (lock) {	178,524,716✔
446	sdbReadLock(pSdb, type);	176,655,294✔
447	}
448
449	SSdbRow **ppRow = taosHashIterate(hash, pIter);	178,524,716✔
450	while (ppRow != NULL) {	178,524,716✔
451	SSdbRow pRow = ppRow;	143,434,362✔
452	if (pRow == NULL) {	143,434,362✔
UNCOV 453	ppRow = taosHashIterate(hash, ppRow);	×
UNCOV 454	continue;	×
455	}
456
457	(void)atomic_add_fetch_32(&pRow->refCount, 1);	143,434,362✔
458	sdbPrintOper(pSdb, pRow, "fetch");	143,434,362✔
459	*ppObj = pRow->pObj;	143,434,362✔
460	*status = pRow->status;	143,434,362✔
461	break;	143,434,362✔
462	}
463	if (lock) {	178,524,716✔
464	sdbUnLock(pSdb, type);	176,655,294✔
465	}
466
467	return ppRow;	178,524,716✔
468	}
469
470	void sdbCancelFetch(SSdb pSdb, void pIter) {	92,464,662✔
471	if (pIter == NULL) return;	92,464,662✔
472	SSdbRow pRow = (SSdbRow **)pIter;	92,376,184✔
473	mTrace("cancel fetch row:%p", pRow);	92,376,184✔
474	SHashObj *hash = sdbGetHash(pSdb, pRow->type);	92,376,184✔
475	if (hash == NULL) return;	92,376,184✔
476
477	int32_t type = pRow->type;	92,376,184✔
478	sdbReadLock(pSdb, type);	92,376,184✔
479	taosHashCancelIterate(hash, pIter);	92,376,184✔
480	sdbUnLock(pSdb, type);	92,376,184✔
481	}
482
483	void sdbCancelFetchByType(SSdb pSdb, void pIter, ESdbType type) {	109✔
484	if (pIter == NULL) return;	109✔
485	if (type >= SDB_MAX \|\| type < 0) return;	109✔
486	SHashObj *hash = sdbGetHash(pSdb, type);	109✔
487	if (hash == NULL) return;	109✔
488
489	sdbReadLock(pSdb, type);	109✔
490	taosHashCancelIterate(hash, pIter);	109✔
491	sdbUnLock(pSdb, type);	109✔
492	}
493
494	void sdbTraverse(SSdb pSdb, ESdbType type, sdbTraverseFp fp, void p1, void p2, void p3) {	10,565,964✔
495	SHashObj *hash = sdbGetHash(pSdb, type);	10,565,964✔
496	if (hash == NULL) return;	10,565,964✔
497
498	sdbReadLock(pSdb, type);	10,565,964✔
499
500	SSdbRow **ppRow = taosHashIterate(hash, NULL);	10,565,964✔
501	while (ppRow != NULL) {	44,154,448✔
502	SSdbRow pRow = ppRow;	33,605,114✔
503	if (pRow->status == SDB_STATUS_READY) {	33,605,114✔
504	bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);	31,567,634✔
505	if (!isContinue) {	31,567,634✔
506	taosHashCancelIterate(hash, ppRow);	16,630✔
507	break;	16,630✔
508	}
509	}
510
511	ppRow = taosHashIterate(hash, ppRow);	33,588,484✔
512	}
513
514	sdbUnLock(pSdb, type);	10,565,964✔
515	}
516
517	int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {	194,574,019✔
518	SHashObj *hash = sdbGetHash(pSdb, type);	194,574,019✔
519	if (hash == NULL) return 0;	194,572,952✔
520
521	sdbReadLock(pSdb, type);	194,572,952✔
522	int32_t size = taosHashGetSize(hash);	194,571,987✔
523	sdbUnLock(pSdb, type);	194,571,631✔
524
525	return size;	194,573,691✔
526	}
527
528	int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {	20,295,086✔
529	SHashObj *hash = sdbGetHash(pSdb, type);	20,295,086✔
530	if (hash == NULL) return -1;	20,295,086✔
531
532	if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;	20,295,086✔
533
534	int32_t maxId = 0;	20,295,086✔
535	sdbReadLock(pSdb, type);	20,295,086✔
536
537	SSdbRow **ppRow = taosHashIterate(hash, NULL);	20,295,086✔
538	while (ppRow != NULL) {	34,593,988✔
539	SSdbRow pRow = ppRow;	14,298,902✔
540	int32_t id = (int32_t )pRow->pObj;	14,298,902✔
541	maxId = TMAX(id, maxId);	14,298,902✔
542	ppRow = taosHashIterate(hash, ppRow);	14,298,902✔
543	}
544
545	sdbUnLock(pSdb, type);	20,295,086✔
546	maxId = TMAX(maxId, pSdb->maxId[type]);	20,295,086✔
547	return maxId + 1;	20,295,086✔
548	}
549
550	int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {	134,797,611✔
551	if (type >= SDB_MAX \|\| type < 0) {	134,797,611✔
UNCOV 552	terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;	×
UNCOV 553	return -1;	×
554	}
555
556	return pSdb->tableVer[type];	134,797,611✔
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) {	441,965✔
573	SHashObj *hash = sdbGetHash(pSdb, type);	441,965✔
574	if (hash == NULL) return false;	441,965✔
575	int32_t keySize = sdbGetkeySize(pSdb, type, pKey);	441,965✔
576
577	sdbReadLock(pSdb, type);	441,965✔
578	void* p = taosHashGet(hash, pKey, keySize);	441,965✔
579	sdbUnLock(pSdb, type);	441,965✔
580
581	return (NULL != p);	441,965✔
582	}
583
584

taosdata / TDengine / #4872

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