• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

taosdata / TDengine / #3583

17 Jan 2025 07:28AM UTC coverage: 63.876% (+0.07%) from 63.803%
#3583

push

travis-ci

web-flow
Merge pull request #29594 from taosdata/fix/insert-when-2-replicas

fix/insert-when-2-replicas

141608 of 284535 branches covered (49.77%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

396 existing lines in 105 files now uncovered.

220075 of 281695 relevant lines covered (78.13%)

19864675.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.79
/source/dnode/mnode/sdb/src/sdbHash.c
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) {
1,744,532✔
22
  switch (type) {
1,744,532!
23
    case SDB_TRANS:
250,388✔
24
      return "trans";
250,388✔
25
    case SDB_CLUSTER:
21,605✔
26
      return "cluster";
21,605✔
27
    case SDB_MNODE:
36,390✔
28
      return "mnode";
36,390✔
29
    case SDB_QNODE:
19,052✔
30
      return "qnode";
19,052✔
31
    case SDB_SNODE:
7,642✔
32
      return "snode";
7,642✔
33
    case SDB_DNODE:
113,916✔
34
      return "dnode";
113,916✔
35
    case SDB_USER:
41,038✔
36
      return "user";
41,038✔
37
    case SDB_AUTH:
2✔
38
      return "auth";
2✔
39
    case SDB_ACCT:
13,932✔
40
      return "acct";
13,932✔
41
    case SDB_STREAM_CK:
2✔
42
      return "stream_ck";
2✔
43
    case SDB_STREAM:
49,155✔
44
      return "stream";
49,155✔
45
    case SDB_OFFSET:
2✔
46
      return "offset";
2✔
47
    case SDB_SUBSCRIBE:
11,348✔
48
      return "subscribe";
11,348✔
49
    case SDB_CONSUMER:
15,088✔
50
      return "consumer";
15,088✔
51
    case SDB_TOPIC:
10,059✔
52
      return "topic";
10,059✔
53
    case SDB_VGROUP:
303,190✔
54
      return "vgroup";
303,190✔
55
    case SDB_SMA:
33,423✔
56
      return "sma";
33,423✔
57
    case SDB_STB:
118,453✔
58
      return "stb";
118,453✔
59
    case SDB_DB:
86,913✔
60
      return "db";
86,913✔
61
    case SDB_FUNC:
7,653✔
62
      return "func";
7,653✔
63
    case SDB_IDX:
56,265✔
64
      return "idx";
56,265✔
65
    case SDB_VIEW:
8,603✔
66
      return "view";
8,603✔
67
    case SDB_STREAM_SEQ:
7,470✔
68
      return "stream_seq";
7,470✔
69
    case SDB_COMPACT:
7,500✔
70
      return "compact";
7,500✔
71
    case SDB_COMPACT_DETAIL:
7,650✔
72
      return "compact_detail";
7,650✔
73
    case SDB_GRANT:
15,635✔
74
      return "grant";
15,635✔
75
    case SDB_ARBGROUP:
7,565✔
76
      return "arb_group";
7,565✔
77
    case SDB_ANODE:
7,481✔
78
      return "anode";
7,481✔
79
    case SDB_CFG:
487,112✔
80
      return "config";
487,112✔
81
    default:
×
82
      return "undefine";
×
83
  }
84
}
85

86
const char *sdbStatusName(ESdbStatus status) {
1,042,419✔
87
  switch (status) {
1,042,419✔
88
    case SDB_STATUS_CREATING:
30,004✔
89
      return "creating";
30,004✔
90
    case SDB_STATUS_DROPPING:
9,245✔
91
      return "dropping";
9,245✔
92
    case SDB_STATUS_READY:
927,105✔
93
      return "ready";
927,105✔
94
    case SDB_STATUS_DROPPED:
66,410✔
95
      return "dropped";
66,410✔
96
    case SDB_STATUS_INIT:
9,625✔
97
      return "init";
9,625✔
98
    case SDB_STATUS_UPDATE:
29✔
99
      return "update";
29✔
100
    default:
1✔
101
      return "undefine";
1✔
102
  }
103
}
104

105
void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) {
403,438,232✔
106
#if 1
107
  EKeyType keyType = pSdb->keyTypes[pRow->type];
403,438,232✔
108

109
  if (keyType == SDB_KEY_BINARY) {
403,438,232✔
110
    mTrace("%s:%s, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj,
47,024,521✔
111
           pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
112
  } else if (keyType == SDB_KEY_INT32) {
356,413,711✔
113
    mTrace("%s:%d, ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj,
356,048,703✔
114
           pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
115
  } else if (keyType == SDB_KEY_INT64) {
365,008!
116
    mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p row->pObj:%p status:%s", sdbTableName(pRow->type),
405,541✔
117
           *(int64_t *)pRow->pObj, pRow->refCount, oper, pRow, pRow->pObj, sdbStatusName(pRow->status));
118
  } else {
119
  }
120
#endif
121
}
403,438,232✔
122

123
static SHashObj *sdbGetHash(SSdb *pSdb, int32_t type) {
213,492,722✔
124
  if (type >= SDB_MAX || type < 0) {
213,492,722!
125
    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;
×
126
    return NULL;
1✔
127
  }
128

129
  SHashObj *hash = pSdb->hashObjs[type];
213,494,228✔
130
  if (hash == NULL) {
213,494,228✔
131
    terrno = TSDB_CODE_APP_ERROR;
4✔
132
    return NULL;
4✔
133
  }
134

135
  return hash;
213,494,224✔
136
}
137

138
static int32_t sdbGetkeySize(SSdb *pSdb, ESdbType type, const void *pKey) {
33,313,472✔
139
  int32_t  keySize = 0;
33,313,472✔
140
  EKeyType keyType = pSdb->keyTypes[type];
33,313,472✔
141

142
  if (keyType == SDB_KEY_INT32) {
33,313,472✔
143
    keySize = sizeof(int32_t);
21,699,661✔
144
  } else if (keyType == SDB_KEY_BINARY) {
11,613,811✔
145
    keySize = strlen(pKey) + 1;
11,594,292✔
146
  } else {
147
    keySize = sizeof(int64_t);
19,519✔
148
  }
149

150
  return keySize;
33,313,472✔
151
}
152

153
static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) {
282,004✔
154
  int32_t type = pRow->type;
282,004✔
155
  sdbWriteLock(pSdb, type);
282,004✔
156

157
  SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);
282,004✔
158
  if (pOldRow != NULL) {
282,004!
159
    sdbUnLock(pSdb, type);
×
160
    sdbFreeRow(pSdb, pRow, false);
×
161
    terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;
×
162
    return terrno;
×
163
  }
164

165
  pRow->refCount = 0;
282,004✔
166
  pRow->status = pRaw->status;
282,004✔
167
  sdbPrintOper(pSdb, pRow, "insert");
282,004✔
168

169
  int32_t code = 0;
282,004✔
170
  if ((code = taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *))) != 0) {
282,004!
171
    sdbUnLock(pSdb, type);
×
172
    sdbFreeRow(pSdb, pRow, false);
×
173
    return code;
×
174
  }
175

176
  SdbInsertFp insertFp = pSdb->insertFps[pRow->type];
282,004✔
177
  if (insertFp != NULL) {
282,004!
178
    code = (*insertFp)(pSdb, pRow->pObj);
282,004✔
179
    if (code != 0) {
282,004!
180
      if (taosHashRemove(hash, pRow->pObj, keySize) != 0) {
×
181
        mError("failed to remove row from hash");
×
182
      }
183
      sdbFreeRow(pSdb, pRow, false);
×
184
      sdbUnLock(pSdb, type);
×
185
      terrno = code;
×
186
      return terrno;
×
187
    }
188
  }
189

190
  sdbUnLock(pSdb, type);
282,004✔
191

192
  if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {
282,004✔
193
    pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], *((int32_t *)pRow->pObj));
68,914✔
194
  }
195
  if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT64) {
282,004✔
196
    pSdb->maxId[pRow->type] = TMAX(pSdb->maxId[pRow->type], *((int64_t *)pRow->pObj));
2,440✔
197
  }
198
  pSdb->tableVer[pRow->type]++;
282,004✔
199

200
  return 0;
282,004✔
201
}
202

203
static int32_t sdbUpdateRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pNewRow, int32_t keySize) {
375,464✔
204
  int32_t type = pNewRow->type;
375,464✔
205
  sdbWriteLock(pSdb, type);
375,464✔
206

207
  SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);
375,464✔
208
  if (ppOldRow == NULL || *ppOldRow == NULL) {
375,464!
209
    sdbUnLock(pSdb, type);
266,453✔
210
    return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);
266,453✔
211
  }
212

213
  SSdbRow *pOldRow = *ppOldRow;
109,011✔
214
  pOldRow->status = pRaw->status;
109,011✔
215
  sdbPrintOper(pSdb, pOldRow, "update");
109,011✔
216

217
  int32_t     code = 0;
109,011✔
218
  SdbUpdateFp updateFp = pSdb->updateFps[type];
109,011✔
219
  if (updateFp != NULL) {
109,011!
220
    code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);
109,011✔
221
  }
222
  sdbUnLock(pSdb, type);
109,011✔
223

224
  // sdbUnLock(pSdb, type);
225
  sdbFreeRow(pSdb, pNewRow, false);
109,011✔
226

227
  pSdb->tableVer[pOldRow->type]++;
109,011✔
228
  return code;
109,011✔
229
}
230

231
static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) {
70,498✔
232
  int32_t type = pRow->type;
70,498✔
233
  sdbWriteLock(pSdb, type);
70,498✔
234

235
  SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);
70,498✔
236
  if (ppOldRow == NULL || *ppOldRow == NULL) {
70,498!
237
    sdbUnLock(pSdb, type);
22✔
238
    sdbFreeRow(pSdb, pRow, false);
22✔
239
    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;
22✔
240
    return terrno;
22✔
241
  }
242
  SSdbRow *pOldRow = *ppOldRow;
70,476✔
243
  pOldRow->status = pRaw->status;
70,476✔
244

245
  (void)atomic_add_fetch_32(&pOldRow->refCount, 1);
70,476✔
246
  sdbPrintOper(pSdb, pOldRow, "delete");
70,476✔
247

248
  if (taosHashRemove(hash, pOldRow->pObj, keySize) != 0) {
70,476!
249
    sdbUnLock(pSdb, type);
×
250
    sdbFreeRow(pSdb, pRow, false);
×
251
    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;
×
252
    return terrno;
×
253
  }
254
  pSdb->tableVer[pOldRow->type]++;
70,476✔
255
  sdbUnLock(pSdb, type);
70,476✔
256

257
  sdbFreeRow(pSdb, pRow, false);
70,476✔
258

259
  sdbCheckRow(pSdb, pOldRow);
70,476✔
260
  return 0;
70,476✔
261
}
262

263
int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw) {
461,515✔
264
  if (pRaw->type == SDB_CFG) {
461,515✔
265
    mTrace("sdb write cfg");
175,986✔
266
  }
267
  SHashObj *hash = sdbGetHash(pSdb, pRaw->type);
461,515✔
268
  if (hash == NULL) return terrno;
461,515✔
269

270
  SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];
461,513✔
271
  SSdbRow    *pRow = (*decodeFp)(pRaw);
461,513✔
272
  if (pRow == NULL) return terrno;
461,513!
273

274
  pRow->type = pRaw->type;
461,513✔
275

276
  int32_t keySize = sdbGetkeySize(pSdb, pRow->type, pRow->pObj);
461,513✔
277
  int32_t code = TSDB_CODE_SDB_INVALID_ACTION_TYPE;
461,513✔
278

279
  switch (pRaw->status) {
461,513!
280
    case SDB_STATUS_CREATING:
15,551✔
281
      code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);
15,551✔
282
      break;
15,551✔
283
    case SDB_STATUS_READY:
375,464✔
284
    case SDB_STATUS_UPDATE:
285
    case SDB_STATUS_DROPPING:
286
      code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);
375,464✔
287
      break;
375,464✔
288
    case SDB_STATUS_DROPPED:
70,498✔
289
      code = sdbDeleteRow(pSdb, hash, pRaw, pRow, keySize);
70,498✔
290
      break;
70,498✔
291
  }
292

293
  return code;
461,513✔
294
}
295

296
int32_t sdbWrite(SSdb *pSdb, SSdbRaw *pRaw) {
51,439✔
297
  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);
51,439✔
298
  sdbFreeRaw(pRaw);
51,439✔
299
  return code;
51,439✔
300
}
301

302
void *sdbAcquireAll(SSdb *pSdb, ESdbType type, const void *pKey, bool onlyReady) {
32,852,397✔
303
  terrno = 0;
32,852,397✔
304

305
  SHashObj *hash = sdbGetHash(pSdb, type);
32,852,160✔
306
  if (hash == NULL) return NULL;
32,851,350✔
307

308
  void   *pRet = NULL;
32,851,349✔
309
  int32_t keySize = sdbGetkeySize(pSdb, type, pKey);
32,851,349✔
310

311
  sdbReadLock(pSdb, type);
32,852,211✔
312

313
  SSdbRow **ppRow = taosHashGet(hash, pKey, keySize);
32,856,985✔
314
  if (ppRow == NULL || *ppRow == NULL) {
32,858,089✔
315
    sdbUnLock(pSdb, type);
1,871,592✔
316
    terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;
1,871,728✔
317
    return NULL;
1,871,723✔
318
  }
319

320
  SSdbRow *pRow = *ppRow;
30,986,497✔
321
  switch (pRow->status) {
30,986,497!
322
    case SDB_STATUS_READY:
30,979,470✔
323
      (void)atomic_add_fetch_32(&pRow->refCount, 1);
30,979,470✔
324
      pRet = pRow->pObj;
30,980,083✔
325
      sdbPrintOper(pSdb, pRow, "acquire");
30,980,083✔
326
      break;
30,978,829✔
327
    case SDB_STATUS_CREATING:
5,190✔
328
      terrno = TSDB_CODE_SDB_OBJ_CREATING;
5,190✔
329
      break;
5,190✔
330
    case SDB_STATUS_DROPPING:
1,847✔
331
      terrno = TSDB_CODE_SDB_OBJ_DROPPING;
1,847✔
332
      break;
1,847✔
UNCOV
333
    default:
×
UNCOV
334
      terrno = TSDB_CODE_APP_ERROR;
×
UNCOV
335
      break;
×
336
  }
337

338
  if (pRet == NULL) {
30,985,866✔
339
    if (!onlyReady) {
7,037!
340
      terrno = 0;
×
341
      (void)atomic_add_fetch_32(&pRow->refCount, 1);
×
342
      pRet = pRow->pObj;
×
343
      sdbPrintOper(pSdb, pRow, "acquire");
×
344
    }
345
  }
346

347
  sdbUnLock(pSdb, type);
30,985,866✔
348
  return pRet;
30,985,847✔
349
}
350

351
void *sdbAcquire(SSdb *pSdb, ESdbType type, const void *pKey) { return sdbAcquireAll(pSdb, type, pKey, true); }
32,848,919✔
352
void *sdbAcquireNotReadyObj(SSdb *pSdb, ESdbType type, const void *pKey) {
2,449✔
353
  return sdbAcquireAll(pSdb, type, pKey, false);
2,449✔
354
}
355

356
static void sdbCheckRow(SSdb *pSdb, SSdbRow *pRow) {
70,476✔
357
  int32_t type = pRow->type;
70,476✔
358
  sdbWriteLock(pSdb, type);
70,476✔
359

360
  int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
70,476✔
361
  sdbPrintOper(pSdb, pRow, "check");
70,476✔
362
  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
70,476!
363
    sdbFreeRow(pSdb, pRow, true);
18,348✔
364
  }
365

366
  sdbUnLock(pSdb, type);
70,476✔
367
}
70,476✔
368

369
void sdbReleaseLock(SSdb *pSdb, void *pObj, bool lock) {
201,409,961✔
370
  if (pObj == NULL) return;
201,409,961✔
371

372
  SSdbRow *pRow = (SSdbRow *)((char *)pObj - sizeof(SSdbRow));
200,989,519✔
373
  if (pRow->type >= SDB_MAX) return;
200,989,519✔
374

375
  int32_t type = pRow->type;
200,989,518✔
376
  if (lock) {
200,989,518!
377
    sdbWriteLock(pSdb, type);
200,990,834✔
378
  }
379

380
  int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
201,050,737✔
381
  sdbPrintOper(pSdb, pRow, "release");
201,067,317✔
382
  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
201,059,056✔
383
    sdbFreeRow(pSdb, pRow, true);
52,128✔
384
  }
385

386
  if (lock) {
201,059,056✔
387
    sdbUnLock(pSdb, type);
201,054,200✔
388
  }
389
}
390

391
void sdbRelease(SSdb *pSdb, void *pObj) { sdbReleaseLock(pSdb, pObj, true); }
201,405,276✔
392

393
void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
171,764,973✔
394
  *ppObj = NULL;
171,764,973✔
395

396
  SHashObj *hash = sdbGetHash(pSdb, type);
171,764,973✔
397
  if (hash == NULL) return NULL;
171,761,320✔
398

399
  sdbReadLock(pSdb, type);
171,761,319✔
400

401
  SSdbRow **ppRow = taosHashIterate(hash, pIter);
171,766,152✔
402
  while (ppRow != NULL) {
171,807,707✔
403
    SSdbRow *pRow = *ppRow;
169,162,073✔
404
    if (pRow == NULL || pRow->status != SDB_STATUS_READY) {
169,162,073✔
405
      ppRow = taosHashIterate(hash, ppRow);
33,064✔
406
      continue;
31,231✔
407
    }
408

409
    (void)atomic_add_fetch_32(&pRow->refCount, 1);
169,129,009✔
410
    sdbPrintOper(pSdb, pRow, "fetch");
169,130,319✔
411
    *ppObj = pRow->pObj;
169,115,648✔
412
    break;
169,115,648✔
413
  }
414
  sdbUnLock(pSdb, type);
171,761,282✔
415

416
  return ppRow;
171,766,208✔
417
}
418

419
void *sdbFetchAll(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj, ESdbStatus *status, bool lock) {
1,073,682✔
420
  *ppObj = NULL;
1,073,682✔
421

422
  SHashObj *hash = sdbGetHash(pSdb, type);
1,073,682✔
423
  if (hash == NULL) return NULL;
1,073,669!
424

425
  if (lock) {
1,073,669✔
426
    sdbReadLock(pSdb, type);
1,067,118✔
427
  }
428

429
  SSdbRow **ppRow = taosHashIterate(hash, pIter);
1,073,573✔
430
  while (ppRow != NULL) {
1,073,777✔
431
    SSdbRow *pRow = *ppRow;
957,020✔
432
    if (pRow == NULL) {
957,020!
433
      ppRow = taosHashIterate(hash, ppRow);
×
434
      continue;
×
435
    }
436

437
    (void)atomic_add_fetch_32(&pRow->refCount, 1);
957,020✔
438
    sdbPrintOper(pSdb, pRow, "fetch");
957,033✔
439
    *ppObj = pRow->pObj;
956,964✔
440
    *status = pRow->status;
956,964✔
441
    break;
956,964✔
442
  }
443
  if (lock) {
1,073,721✔
444
    sdbUnLock(pSdb, type);
1,067,156✔
445
  }
446

447
  return ppRow;
1,073,654✔
448
}
449

450
void sdbCancelFetch(SSdb *pSdb, void *pIter) {
5,281,152✔
451
  if (pIter == NULL) return;
5,281,152✔
452
  SSdbRow *pRow = *(SSdbRow **)pIter;
5,279,062✔
453
  mTrace("cancel fetch row:%p", pRow);
5,279,062✔
454
  SHashObj *hash = sdbGetHash(pSdb, pRow->type);
5,279,062✔
455
  if (hash == NULL) return;
5,279,073!
456

457
  int32_t type = pRow->type;
5,279,073✔
458
  sdbReadLock(pSdb, type);
5,279,073✔
459
  taosHashCancelIterate(hash, pIter);
5,279,119✔
460
  sdbUnLock(pSdb, type);
5,279,157✔
461
}
462

463
void sdbCancelFetchByType(SSdb *pSdb, void *pIter, ESdbType type) {
×
464
  if (pIter == NULL) return;
×
465
  if (type >= SDB_MAX || type < 0) return;
×
466
  SHashObj *hash = sdbGetHash(pSdb, type);
×
467
  if (hash == NULL) return;
×
468

469
  sdbReadLock(pSdb, type);
×
470
  taosHashCancelIterate(hash, pIter);
×
471
  sdbUnLock(pSdb, type);
×
472
}
473

474
void sdbTraverse(SSdb *pSdb, ESdbType type, sdbTraverseFp fp, void *p1, void *p2, void *p3) {
688,008✔
475
  SHashObj *hash = sdbGetHash(pSdb, type);
688,008✔
476
  if (hash == NULL) return;
687,996!
477

478
  sdbReadLock(pSdb, type);
687,996✔
479

480
  SSdbRow **ppRow = taosHashIterate(hash, NULL);
687,995✔
481
  while (ppRow != NULL) {
32,538,900✔
482
    SSdbRow *pRow = *ppRow;
31,853,767✔
483
    if (pRow->status == SDB_STATUS_READY) {
31,853,767✔
484
      bool isContinue = (*fp)(pSdb->pMnode, pRow->pObj, p1, p2, p3);
31,831,502✔
485
      if (!isContinue) {
31,674,432✔
486
        taosHashCancelIterate(hash, ppRow);
2✔
487
        break;
2✔
488
      }
489
    }
490

491
    ppRow = taosHashIterate(hash, ppRow);
31,696,695✔
492
  }
493

494
  sdbUnLock(pSdb, type);
685,135✔
495
}
496

497
int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {
1,364,528✔
498
  SHashObj *hash = sdbGetHash(pSdb, type);
1,364,528✔
499
  if (hash == NULL) return 0;
1,364,418!
500

501
  sdbReadLock(pSdb, type);
1,364,418✔
502
  int32_t size = taosHashGetSize(hash);
1,364,614✔
503
  sdbUnLock(pSdb, type);
1,364,432✔
504

505
  return size;
1,364,649✔
506
}
507

508
int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {
58,392✔
509
  SHashObj *hash = sdbGetHash(pSdb, type);
58,392✔
510
  if (hash == NULL) return -1;
58,392✔
511

512
  if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;
58,391✔
513

514
  int32_t maxId = 0;
58,385✔
515
  sdbReadLock(pSdb, type);
58,385✔
516

517
  SSdbRow **ppRow = taosHashIterate(hash, NULL);
58,385✔
518
  while (ppRow != NULL) {
126,030✔
519
    SSdbRow *pRow = *ppRow;
67,645✔
520
    int32_t  id = *(int32_t *)pRow->pObj;
67,645✔
521
    maxId = TMAX(id, maxId);
67,645✔
522
    ppRow = taosHashIterate(hash, ppRow);
67,645✔
523
  }
524

525
  sdbUnLock(pSdb, type);
58,385✔
526
  maxId = TMAX(maxId, pSdb->maxId[type]);
58,385✔
527
  return maxId + 1;
58,385✔
528
}
529

530
int64_t sdbGetTableVer(SSdb *pSdb, ESdbType type) {
605,510✔
531
  if (type >= SDB_MAX || type < 0) {
605,510✔
532
    terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;
1✔
533
    return -1;
1✔
534
  }
535

536
  return pSdb->tableVer[type];
605,509✔
537
}
538

539
bool countValid(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
×
540
  int32_t *pInt = p1;
×
541
  (*pInt) += 1;
×
542
  return true;
×
543
}
544

545
int32_t sdbGetValidSize(SSdb *pSdb, ESdbType type) {
×
546
  int32_t num = 0;
×
547
  sdbTraverse(pSdb, type, countValid, &num, 0, 0);
×
548
  return num;
×
549
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc