taosdata/TDengine | Build 4908 | source/dnode/vnode/src/tsdb/tsdbUtil2.c | Coveralls

19

void tTombBlockInit(STombBlock *tombBlock) {

1,402,587✔

20

  tombBlock->numOfRecords = 0;

1,402,587✔

21

  for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {

8,415,522✔

22

    tBufferInit(&tombBlock->buffers[i]);

7,012,935✔

24

  return;

1,402,587✔

27

void tTombBlockDestroy(STombBlock *tombBlock) {

26,519,066✔

28

  tombBlock->numOfRecords = 0;

26,519,066✔

29

  for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {

159,124,309✔

30

    tBufferDestroy(&tombBlock->buffers[i]);

132,592,766✔

32

26,531,543✔

34

void tTombBlockClear(STombBlock *tombBlock) {

8,956,587✔

35

  tombBlock->numOfRecords = 0;

8,956,587✔

36

  for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {

53,739,522✔

37

    tBufferClear(&tombBlock->buffers[i]);

44,782,935✔

39

8,956,587✔

41

int32_t tTombBlockPut(STombBlock *tombBlock, const STombRecord *record) {

36,516,414✔

42

  for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {

219,098,484✔

43

    TAOS_CHECK_RETURN(tBufferPutI64(&tombBlock->buffers[i], record->data[i]));

365,164,140✔

45

  tombBlock->numOfRecords++;

36,516,414✔

46

  return 0;

36,516,414✔

49

int32_t tTombBlockGet(STombBlock *tombBlock, int32_t idx, STombRecord *record) {

597,943,844✔

50

  if (idx < 0 || idx >= tombBlock->numOfRecords) {

597,943,844✔

54

  for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {

2,147,483,647✔

55

    SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * idx, &tombBlock->buffers[i]);

2,147,483,647✔

56

    TAOS_CHECK_RETURN(tBufferGetI64(&br, &record->data[i]));

2,147,483,647✔

58

  return 0;

597,943,844✔

61

int32_t tTombRecordCompare(const STombRecord *r1, const STombRecord *r2) {

30,372,674✔

62

  if (r1->suid < r2->suid) return -1;

30,372,674✔

63

  if (r1->suid > r2->suid) return 1;

30,372,674✔

64

  if (r1->uid < r2->uid) return -1;

963,749✔

65

  if (r1->uid > r2->uid) return 1;

963,749✔

66

  if (r1->version < r2->version) return -1;

963,749✔

67

  if (r1->version > r2->version) return 1;

963,749✔

72

int32_t tStatisBlockInit(STbStatisBlock *statisBlock) {

237,022,036✔

73

  int32_t code = 0;

237,022,036✔

75

  statisBlock->numOfPKs = 0;

237,022,036✔

76

  statisBlock->numOfRecords = 0;

237,096,565✔

77

  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {

1,422,401,039✔

78

    tBufferInit(&statisBlock->buffers[i]);

1,185,297,511✔

80

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

711,385,557✔

81

    TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->firstKeyPKs[i]), NULL, _exit);

474,121,770✔

82

    TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->lastKeyPKs[i]), NULL, _exit);

474,214,588✔

85

_exit:

237,263,787✔

86

  if (code) {

237,263,787✔

89

  return code;

237,101,052✔

92

void tStatisBlockDestroy(STbStatisBlock *statisBlock) {

253,461,795✔

93

  statisBlock->numOfPKs = 0;

253,461,795✔

94

  statisBlock->numOfRecords = 0;

253,506,680✔

95

  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {

1,521,127,263✔

96

    tBufferDestroy(&statisBlock->buffers[i]);

1,267,565,995✔

98

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

760,699,379✔

99

    tValueColumnDestroy(&statisBlock->firstKeyPKs[i]);

507,126,191✔

100

    tValueColumnDestroy(&statisBlock->lastKeyPKs[i]);

507,079,520✔

102

253,573,188✔

104

void tStatisBlockClear(STbStatisBlock *statisBlock) {

261,738,154✔

105

  statisBlock->numOfPKs = 0;

261,738,154✔

106

  statisBlock->numOfRecords = 0;

261,762,845✔

107

  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {

1,570,352,156✔

108

    tBufferClear(&statisBlock->buffers[i]);

1,308,594,820✔

110

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

785,167,323✔

111

    tValueColumnClear(&statisBlock->firstKeyPKs[i]);

523,461,252✔

112

    tValueColumnClear(&statisBlock->lastKeyPKs[i]);

523,435,886✔

114

  return;

261,706,071✔

117

static int32_t tStatisBlockAppend(STbStatisBlock *block, SRowInfo *row) {

98,313,974✔

118

  STsdbRowKey key;

98,312,282✔

120

  tsdbRowGetKey(&row->row, &key);

98,325,021✔

121

  if (block->numOfRecords == 0) {

98,335,648✔

122

    block->numOfPKs = key.key.numOfPKs;

16,630,852✔

123

  } else if (block->numOfPKs != key.key.numOfPKs) {

81,702,374✔

124

    return TSDB_CODE_INVALID_PARA;

34,836✔

126

    for (int i = 0; i < block->numOfPKs; i++) {

82,167,750✔

127

      if (key.key.pks[i].type != block->firstKeyPKs[i].type) {

532,436✔

128

        return TSDB_CODE_INVALID_PARA;

33,479✔

133

  TAOS_CHECK_RETURN(tBufferPutI64(&block->suids, row->suid));

196,522,022✔

134

  TAOS_CHECK_RETURN(tBufferPutI64(&block->uids, row->uid));

196,537,411✔

135

  TAOS_CHECK_RETURN(tBufferPutI64(&block->firstKeyTimestamps, key.key.ts));

196,525,763✔

136

  TAOS_CHECK_RETURN(tBufferPutI64(&block->lastKeyTimestamps, key.key.ts));

196,526,714✔

137

  TAOS_CHECK_RETURN(tBufferPutI64(&block->counts, 1));

196,526,934✔

138

  for (int32_t i = 0; i < block->numOfPKs; ++i) {

99,030,055✔

139

    TAOS_CHECK_RETURN(tValueColumnAppend(block->firstKeyPKs + i, key.key.pks + i));

770,988✔

140

    TAOS_CHECK_RETURN(tValueColumnAppend(block->lastKeyPKs + i, key.key.pks + i));

770,988✔

143

  block->numOfRecords++;

98,238,836✔

144

  return 0;

98,232,393✔

147

static int32_t tStatisBlockUpdate(STbStatisBlock *block, SRowInfo *row) {

2,147,483,647✔

148

  STbStatisRecord record;

2,147,483,647✔

149

  STsdbRowKey     key;

2,147,483,647✔

152

  TAOS_CHECK_RETURN(tStatisBlockGet(block, block->numOfRecords - 1, &record));

2,147,483,647✔

153

  tsdbRowGetKey(&row->row, &key);

2,147,483,647✔

155

  c = tRowKeyCompare(&record.lastKey, &key.key);

2,147,483,647✔

156

  if (c == 0) {

2,147,483,647✔

157

    return 0;

59,012,683✔

158

  } else if (c < 0) {

2,147,483,647✔

160

    TAOS_CHECK_RETURN(tBufferPutAt(&block->lastKeyTimestamps, (block->numOfRecords - 1) * sizeof(record.lastKey.ts),

2,147,483,647✔

164

    for (int i = 0; i < block->numOfPKs; i++) {

2,147,483,647✔

165

      TAOS_CHECK_RETURN(tValueColumnUpdate(&block->lastKeyPKs[i], block->numOfRecords - 1, &key.key.pks[i]));

49,686,128✔

169

    record.count++;

2,147,483,647✔

170

    TAOS_CHECK_RETURN(tBufferPutAt(&block->counts, (block->numOfRecords - 1) * sizeof(record.count), &record.count,

2,147,483,647✔

176

  return 0;

2,147,483,647✔

179

int32_t tStatisBlockPut(STbStatisBlock *block, SRowInfo *row, int32_t maxRecords) {

2,147,483,647✔

180

  if (block->numOfRecords > 0) {

2,147,483,647✔

181

    int64_t       lastUid;

2,147,483,647✔

182

    SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * (block->numOfRecords - 1), &block->uids);

2,147,483,647✔

183

    TAOS_CHECK_RETURN(tBufferGetI64(&br, &lastUid));

2,147,483,647✔

185

    if (lastUid == row->uid) {

2,147,483,647✔

186

      return tStatisBlockUpdate(block, row);

2,147,483,647✔

187

    } else if (block->numOfRecords >= maxRecords) {

81,722,499✔

188

      return TSDB_CODE_INVALID_PARA;

8,904✔

191

  return tStatisBlockAppend(block, row);

98,810,643✔

194

int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecord *record) {

2,147,483,647✔

195

  SBufferReader reader;

2,147,483,647✔

197

  if (idx < 0 || idx >= statisBlock->numOfRecords) {

2,147,483,647✔

201

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->suid), &statisBlock->suids);

2,147,483,647✔

202

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));

2,147,483,647✔

204

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->uid), &statisBlock->uids);

2,147,483,647✔

205

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));

2,147,483,647✔

207

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->firstKey.ts), &statisBlock->firstKeyTimestamps);

2,147,483,647✔

208

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.ts));

2,147,483,647✔

210

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->lastKey.ts), &statisBlock->lastKeyTimestamps);

2,147,483,647✔

211

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.ts));

2,147,483,647✔

213

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->count), &statisBlock->counts);

2,147,483,647✔

214

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->count));

2,147,483,647✔

217

  for (record->firstKey.numOfPKs = 0; record->firstKey.numOfPKs < statisBlock->numOfPKs; record->firstKey.numOfPKs++) {

2,147,483,647✔

218

    TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->firstKeyPKs[record->firstKey.numOfPKs], idx,

92,980,668✔

222

  for (record->lastKey.numOfPKs = 0; record->lastKey.numOfPKs < statisBlock->numOfPKs; record->lastKey.numOfPKs++) {

2,147,483,647✔

223

    TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->lastKeyPKs[record->lastKey.numOfPKs], idx,

92,981,073✔

227

  return 0;

2,147,483,647✔

231

int32_t tBrinBlockInit(SBrinBlock *brinBlock) {

20,298✔

234

  brinBlock->numOfPKs = 0;

20,298✔

235

  brinBlock->numOfRecords = 0;

20,298✔

236

  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {

324,768✔

237

    tBufferInit(&brinBlock->buffers[i]);

304,470✔

239

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

60,894✔

240

    TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->firstKeyPKs[i]), NULL, _exit);

40,596✔

241

    TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->lastKeyPKs[i]), NULL, _exit);

40,596✔

244

_exit:

20,298✔

245

  if (code) {

20,298✔

248

  return code;

20,298✔

251

void tBrinBlockDestroy(SBrinBlock *brinBlock) {

367,341,584✔

252

  brinBlock->numOfPKs = 0;

367,341,584✔

253

  brinBlock->numOfRecords = 0;

367,455,459✔

254

  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {

2,147,483,647✔

255

    tBufferDestroy(&brinBlock->buffers[i]);

2,147,483,647✔

257

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

1,102,613,220✔

258

    tValueColumnDestroy(&brinBlock->firstKeyPKs[i]);

735,047,475✔

259

    tValueColumnDestroy(&brinBlock->lastKeyPKs[i]);

734,950,144✔

261

367,565,745✔

263

void tBrinBlockClear(SBrinBlock *brinBlock) {

31,679,264✔

264

  brinBlock->numOfPKs = 0;

31,679,264✔

265

  brinBlock->numOfRecords = 0;

31,682,712✔

266

  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {

506,871,962✔

267

    tBufferClear(&brinBlock->buffers[i]);

475,184,141✔

269

  for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {

95,052,738✔

270

    tValueColumnClear(&brinBlock->firstKeyPKs[i]);

63,369,842✔

271

    tValueColumnClear(&brinBlock->lastKeyPKs[i]);

63,370,273✔

273

31,682,896✔

275

int32_t tBrinBlockPut(SBrinBlock *brinBlock, const SBrinRecord *record) {

34,060,685✔

276

  if (record->firstKey.key.numOfPKs != record->lastKey.key.numOfPKs) {

34,060,685✔

280

  if (brinBlock->numOfRecords == 0) {  // the first row

34,061,604✔

281

    brinBlock->numOfPKs = record->firstKey.key.numOfPKs;

669,752✔

282

  } else if (brinBlock->numOfPKs != record->firstKey.key.numOfPKs) {

33,390,941✔

287

    for (int i = 0; i < brinBlock->numOfPKs; i++) {

33,393,257✔

288

      if (record->firstKey.key.pks[i].type != brinBlock->firstKeyPKs[i].type) {

2,022✔

294

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->suids, record->suid));

68,119,560✔

295

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->uids, record->uid));

68,118,748✔

296

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyTimestamps, record->firstKey.key.ts));

68,115,844✔

297

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyVersions, record->firstKey.version));

68,112,960✔

298

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyTimestamps, record->lastKey.key.ts));

68,111,574✔

299

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyVersions, record->lastKey.version));

68,109,350✔

300

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->minVers, record->minVer));

68,110,424✔

301

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->maxVers, record->maxVer));

68,112,281✔

302

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->blockOffsets, record->blockOffset));

68,106,871✔

303

  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->smaOffsets, record->smaOffset));

68,103,865✔

304

  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockSizes, record->blockSize));

68,106,616✔

305

  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockKeySizes, record->blockKeySize));

68,108,882✔

306

  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->smaSizes, record->smaSize));

68,105,568✔

307

  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->numRows, record->numRow));

68,102,910✔

308

  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->counts, record->count));

68,106,874✔

310

  if (brinBlock->numOfPKs > 0) {

34,054,552✔

311

    for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) {

7,774✔

312

      TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->firstKeyPKs[i], &record->firstKey.key.pks[i]));

3,887✔

315

    for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) {

7,774✔

316

      TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->lastKeyPKs[i], &record->lastKey.key.pks[i]));

3,887✔

320

  brinBlock->numOfRecords++;

34,053,821✔

322

  return 0;

34,055,839✔

325

int32_t tBrinBlockGet(SBrinBlock *brinBlock, int32_t idx, SBrinRecord *record) {

115,084,791✔

326

  SBufferReader reader;

115,084,791✔

328

  if (idx < 0 || idx >= brinBlock->numOfRecords) {

115,086,537✔

332

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->suids);

115,088,869✔

333

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));

115,088,254✔

335

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->uids);

115,084,617✔

336

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));

115,087,330✔

338

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyTimestamps);

115,086,920✔

339

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.key.ts));

115,082,170✔

341

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyVersions);

115,084,329✔

342

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.version));

115,083,283✔

344

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyTimestamps);

115,082,100✔

345

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.key.ts));

115,086,432✔

347

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyVersions);

115,079,283✔

348

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.version));

115,078,642✔

350

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->minVers);

115,084,063✔

351

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->minVer));

115,083,632✔

353

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->maxVers);

115,084,699✔

354

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->maxVer));

115,085,992✔

356

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->blockOffsets);

115,082,921✔

357

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->blockOffset));

115,084,089✔

359

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->smaOffsets);

115,084,258✔

360

  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->smaOffset));

115,084,096✔

362

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockSizes);

115,080,846✔

363

  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockSize));

115,083,049✔

365

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockKeySizes);

115,080,021✔

366

  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockKeySize));

115,085,300✔

368

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->smaSizes);

115,087,183✔

369

  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->smaSize));

115,083,982✔

371

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->numRows);

115,082,020✔

372

  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->numRow));

115,082,595✔

374

  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->counts);

115,077,531✔

375

  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->count));

115,078,824✔

378

  for (record->firstKey.key.numOfPKs = 0; record->firstKey.key.numOfPKs < brinBlock->numOfPKs;

115,093,836✔

379

       record->firstKey.key.numOfPKs++) {

9,122✔

380

    TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->firstKeyPKs[record->firstKey.key.numOfPKs], idx,

9,122✔

384

  for (record->lastKey.key.numOfPKs = 0; record->lastKey.key.numOfPKs < brinBlock->numOfPKs;

115,090,692✔

385

       record->lastKey.key.numOfPKs++) {

9,122✔

386

    TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->lastKeyPKs[record->lastKey.key.numOfPKs], idx,

9,122✔

390

  return 0;

115,078,743✔

394

int32_t tsdbUpdateSkmTb(STsdb *pTsdb, const TABLEID *tbid, SSkmInfo *pSkmTb) {

70,390,923✔

395

  if (tbid->suid) {

70,390,923✔

396

    if (pSkmTb->suid == tbid->suid) {

52,524,454✔

397

      pSkmTb->uid = tbid->uid;

35,790,523✔

398

      return 0;

35,790,188✔

400

  } else if (pSkmTb->uid == tbid->uid) {

17,886,871✔

401

    return 0;

228,679✔

404

  pSkmTb->suid = tbid->suid;

34,413,764✔

405

  pSkmTb->uid = tbid->uid;

34,414,257✔

406

  tDestroyTSchema(pSkmTb->pTSchema);

34,419,488✔

407

  return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, -1, &pSkmTb->pTSchema);

34,413,551✔

410

int32_t tsdbUpdateSkmRow(STsdb *pTsdb, const TABLEID *tbid, int32_t sver, SSkmInfo *pSkmRow) {

2,147,483,647✔

411

  if (pSkmRow->pTSchema && pSkmRow->suid == tbid->suid) {

2,147,483,647✔

412

    if (pSkmRow->suid) {

2,147,483,647✔

413

      if (sver == pSkmRow->pTSchema->version) return 0;

2,147,483,647✔

414

    } else if (pSkmRow->uid == tbid->uid && pSkmRow->pTSchema->version == sver) {

1,196,750,562✔

415

      return 0;

1,188,345,492✔

419

  pSkmRow->suid = tbid->suid;

35,780,588✔

420

  pSkmRow->uid = tbid->uid;

33,765,316✔

421

  tDestroyTSchema(pSkmRow->pTSchema);

33,769,084✔

422

  return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, sver, &pSkmRow->pTSchema);

33,767,025✔

taosdata / TDengine / #4908

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	#include "tsdbUtil2.h"
17
18	// SDelBlock ----------
19	void tTombBlockInit(STombBlock *tombBlock) {	1,402,587✔
20	tombBlock->numOfRecords = 0;	1,402,587✔
21	for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {	8,415,522✔
22	tBufferInit(&tombBlock->buffers[i]);	7,012,935✔
23	}
24	return;	1,402,587✔
25	}
26
27	void tTombBlockDestroy(STombBlock *tombBlock) {	26,519,066✔
28	tombBlock->numOfRecords = 0;	26,519,066✔
29	for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {	159,124,309✔
30	tBufferDestroy(&tombBlock->buffers[i]);	132,592,766✔
31	}
32	}	26,531,543✔
33
34	void tTombBlockClear(STombBlock *tombBlock) {	8,956,587✔
35	tombBlock->numOfRecords = 0;	8,956,587✔
36	for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {	53,739,522✔
37	tBufferClear(&tombBlock->buffers[i]);	44,782,935✔
38	}
39	}	8,956,587✔
40
41	int32_t tTombBlockPut(STombBlock tombBlock, const STombRecord record) {	36,516,414✔
42	for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {	219,098,484✔
43	TAOS_CHECK_RETURN(tBufferPutI64(&tombBlock->buffers[i], record->data[i]));	365,164,140✔
44	}
45	tombBlock->numOfRecords++;	36,516,414✔
46	return 0;	36,516,414✔
47	}
48
49	int32_t tTombBlockGet(STombBlock tombBlock, int32_t idx, STombRecord record) {	597,943,844✔
50	if (idx < 0 \|\| idx >= tombBlock->numOfRecords) {	597,943,844✔
51	return TSDB_CODE_OUT_OF_RANGE;	×
52	}
53
54	for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) {	2,147,483,647✔
55	SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * idx, &tombBlock->buffers[i]);	2,147,483,647✔
56	TAOS_CHECK_RETURN(tBufferGetI64(&br, &record->data[i]));	2,147,483,647✔
57	}
58	return 0;	597,943,844✔
59	}
60
61	int32_t tTombRecordCompare(const STombRecord r1, const STombRecord r2) {	30,372,674✔
62	if (r1->suid < r2->suid) return -1;	30,372,674✔
63	if (r1->suid > r2->suid) return 1;	30,372,674✔
64	if (r1->uid < r2->uid) return -1;	963,749✔
65	if (r1->uid > r2->uid) return 1;	963,749✔
66	if (r1->version < r2->version) return -1;	963,749✔
67	if (r1->version > r2->version) return 1;	963,749✔
68	return 0;	×
69	}
70
71	// STbStatisBlock ----------
72	int32_t tStatisBlockInit(STbStatisBlock *statisBlock) {	237,022,036✔
73	int32_t code = 0;	237,022,036✔
74
75	statisBlock->numOfPKs = 0;	237,022,036✔
76	statisBlock->numOfRecords = 0;	237,096,565✔
77	for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {	1,422,401,039✔
78	tBufferInit(&statisBlock->buffers[i]);	1,185,297,511✔
79	}
80	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	711,385,557✔
81	TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->firstKeyPKs[i]), NULL, _exit);	474,121,770✔
82	TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->lastKeyPKs[i]), NULL, _exit);	474,214,588✔
83	}
84
85	_exit:	237,263,787✔
86	if (code) {	237,263,787✔
87	tStatisBlockDestroy(statisBlock);	×
88	}
89	return code;	237,101,052✔
90	}
91
92	void tStatisBlockDestroy(STbStatisBlock *statisBlock) {	253,461,795✔
93	statisBlock->numOfPKs = 0;	253,461,795✔
94	statisBlock->numOfRecords = 0;	253,506,680✔
95	for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {	1,521,127,263✔
96	tBufferDestroy(&statisBlock->buffers[i]);	1,267,565,995✔
97	}
98	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	760,699,379✔
99	tValueColumnDestroy(&statisBlock->firstKeyPKs[i]);	507,126,191✔
100	tValueColumnDestroy(&statisBlock->lastKeyPKs[i]);	507,079,520✔
101	}
102	}	253,573,188✔
103
104	void tStatisBlockClear(STbStatisBlock *statisBlock) {	261,738,154✔
105	statisBlock->numOfPKs = 0;	261,738,154✔
106	statisBlock->numOfRecords = 0;	261,762,845✔
107	for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {	1,570,352,156✔
108	tBufferClear(&statisBlock->buffers[i]);	1,308,594,820✔
109	}
110	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	785,167,323✔
111	tValueColumnClear(&statisBlock->firstKeyPKs[i]);	523,461,252✔
112	tValueColumnClear(&statisBlock->lastKeyPKs[i]);	523,435,886✔
113	}
114	return;	261,706,071✔
115	}
116
117	static int32_t tStatisBlockAppend(STbStatisBlock block, SRowInfo row) {	98,313,974✔
118	STsdbRowKey key;	98,312,282✔
119
120	tsdbRowGetKey(&row->row, &key);	98,325,021✔
121	if (block->numOfRecords == 0) {	98,335,648✔
122	block->numOfPKs = key.key.numOfPKs;	16,630,852✔
123	} else if (block->numOfPKs != key.key.numOfPKs) {	81,702,374✔
124	return TSDB_CODE_INVALID_PARA;	34,836✔
125	} else {
126	for (int i = 0; i < block->numOfPKs; i++) {	82,167,750✔
127	if (key.key.pks[i].type != block->firstKeyPKs[i].type) {	532,436✔
128	return TSDB_CODE_INVALID_PARA;	33,479✔
129	}
130	}
131	}
132
133	TAOS_CHECK_RETURN(tBufferPutI64(&block->suids, row->suid));	196,522,022✔
134	TAOS_CHECK_RETURN(tBufferPutI64(&block->uids, row->uid));	196,537,411✔
135	TAOS_CHECK_RETURN(tBufferPutI64(&block->firstKeyTimestamps, key.key.ts));	196,525,763✔
136	TAOS_CHECK_RETURN(tBufferPutI64(&block->lastKeyTimestamps, key.key.ts));	196,526,714✔
137	TAOS_CHECK_RETURN(tBufferPutI64(&block->counts, 1));	196,526,934✔
138	for (int32_t i = 0; i < block->numOfPKs; ++i) {	99,030,055✔
139	TAOS_CHECK_RETURN(tValueColumnAppend(block->firstKeyPKs + i, key.key.pks + i));	770,988✔
140	TAOS_CHECK_RETURN(tValueColumnAppend(block->lastKeyPKs + i, key.key.pks + i));	770,988✔
141	}
142
143	block->numOfRecords++;	98,238,836✔
144	return 0;	98,232,393✔
145	}
146
147	static int32_t tStatisBlockUpdate(STbStatisBlock block, SRowInfo row) {	2,147,483,647✔
148	STbStatisRecord record;	2,147,483,647✔
149	STsdbRowKey key;	2,147,483,647✔
150	int32_t c;
151
152	TAOS_CHECK_RETURN(tStatisBlockGet(block, block->numOfRecords - 1, &record));	2,147,483,647✔
153	tsdbRowGetKey(&row->row, &key);	2,147,483,647✔
154
155	c = tRowKeyCompare(&record.lastKey, &key.key);	2,147,483,647✔
156	if (c == 0) {	2,147,483,647✔
157	return 0;	59,012,683✔
158	} else if (c < 0) {	2,147,483,647✔
159	// last ts
160	TAOS_CHECK_RETURN(tBufferPutAt(&block->lastKeyTimestamps, (block->numOfRecords - 1) * sizeof(record.lastKey.ts),	2,147,483,647✔
161	&key.key.ts, sizeof(key.key.ts)));
162
163	// last primary keys
164	for (int i = 0; i < block->numOfPKs; i++) {	2,147,483,647✔
165	TAOS_CHECK_RETURN(tValueColumnUpdate(&block->lastKeyPKs[i], block->numOfRecords - 1, &key.key.pks[i]));	49,686,128✔
166	}
167
168	// count
169	record.count++;	2,147,483,647✔
170	TAOS_CHECK_RETURN(tBufferPutAt(&block->counts, (block->numOfRecords - 1) * sizeof(record.count), &record.count,	2,147,483,647✔
171	sizeof(record.count)));
172	} else {
173	return TSDB_CODE_INVALID_PARA;	×
174	}
175
176	return 0;	2,147,483,647✔
177	}
178
179	int32_t tStatisBlockPut(STbStatisBlock block, SRowInfo row, int32_t maxRecords) {	2,147,483,647✔
180	if (block->numOfRecords > 0) {	2,147,483,647✔
181	int64_t lastUid;	2,147,483,647✔
182	SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * (block->numOfRecords - 1), &block->uids);	2,147,483,647✔
183	TAOS_CHECK_RETURN(tBufferGetI64(&br, &lastUid));	2,147,483,647✔
184
185	if (lastUid == row->uid) {	2,147,483,647✔
186	return tStatisBlockUpdate(block, row);	2,147,483,647✔
187	} else if (block->numOfRecords >= maxRecords) {	81,722,499✔
188	return TSDB_CODE_INVALID_PARA;	8,904✔
189	}
190	}
191	return tStatisBlockAppend(block, row);	98,810,643✔
192	}
193
194	int32_t tStatisBlockGet(STbStatisBlock statisBlock, int32_t idx, STbStatisRecord record) {	2,147,483,647✔
195	SBufferReader reader;	2,147,483,647✔
196
197	if (idx < 0 \|\| idx >= statisBlock->numOfRecords) {	2,147,483,647✔
198	return TSDB_CODE_OUT_OF_RANGE;	×
199	}
200
201	reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->suid), &statisBlock->suids);	2,147,483,647✔
202	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));	2,147,483,647✔
203
204	reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->uid), &statisBlock->uids);	2,147,483,647✔
205	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));	2,147,483,647✔
206
207	reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->firstKey.ts), &statisBlock->firstKeyTimestamps);	2,147,483,647✔
208	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.ts));	2,147,483,647✔
209
210	reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->lastKey.ts), &statisBlock->lastKeyTimestamps);	2,147,483,647✔
211	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.ts));	2,147,483,647✔
212
213	reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->count), &statisBlock->counts);	2,147,483,647✔
214	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->count));	2,147,483,647✔
215
216	// primary keys
217	for (record->firstKey.numOfPKs = 0; record->firstKey.numOfPKs < statisBlock->numOfPKs; record->firstKey.numOfPKs++) {	2,147,483,647✔
218	TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->firstKeyPKs[record->firstKey.numOfPKs], idx,	92,980,668✔
219	&record->firstKey.pks[record->firstKey.numOfPKs]));
220	}
221
222	for (record->lastKey.numOfPKs = 0; record->lastKey.numOfPKs < statisBlock->numOfPKs; record->lastKey.numOfPKs++) {	2,147,483,647✔
223	TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->lastKeyPKs[record->lastKey.numOfPKs], idx,	92,981,073✔
224	&record->lastKey.pks[record->lastKey.numOfPKs]));
225	}
226
227	return 0;	2,147,483,647✔
228	}
229
230	// SBrinRecord ----------
231	int32_t tBrinBlockInit(SBrinBlock *brinBlock) {	20,298✔
232	int32_t code;
233
234	brinBlock->numOfPKs = 0;	20,298✔
235	brinBlock->numOfRecords = 0;	20,298✔
236	for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {	324,768✔
237	tBufferInit(&brinBlock->buffers[i]);	304,470✔
238	}
239	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	60,894✔
240	TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->firstKeyPKs[i]), NULL, _exit);	40,596✔
241	TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->lastKeyPKs[i]), NULL, _exit);	40,596✔
242	}
243
244	_exit:	20,298✔
245	if (code) {	20,298✔
246	tBrinBlockDestroy(brinBlock);	×
247	}
248	return code;	20,298✔
249	}
250
251	void tBrinBlockDestroy(SBrinBlock *brinBlock) {	367,341,584✔
252	brinBlock->numOfPKs = 0;	367,341,584✔
253	brinBlock->numOfRecords = 0;	367,455,459✔
254	for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {	2,147,483,647✔
255	tBufferDestroy(&brinBlock->buffers[i]);	2,147,483,647✔
256	}
257	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	1,102,613,220✔
258	tValueColumnDestroy(&brinBlock->firstKeyPKs[i]);	735,047,475✔
259	tValueColumnDestroy(&brinBlock->lastKeyPKs[i]);	734,950,144✔
260	}
261	}	367,565,745✔
262
263	void tBrinBlockClear(SBrinBlock *brinBlock) {	31,679,264✔
264	brinBlock->numOfPKs = 0;	31,679,264✔
265	brinBlock->numOfRecords = 0;	31,682,712✔
266	for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {	506,871,962✔
267	tBufferClear(&brinBlock->buffers[i]);	475,184,141✔
268	}
269	for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {	95,052,738✔
270	tValueColumnClear(&brinBlock->firstKeyPKs[i]);	63,369,842✔
271	tValueColumnClear(&brinBlock->lastKeyPKs[i]);	63,370,273✔
272	}
273	}	31,682,896✔
274
275	int32_t tBrinBlockPut(SBrinBlock brinBlock, const SBrinRecord record) {	34,060,685✔
276	if (record->firstKey.key.numOfPKs != record->lastKey.key.numOfPKs) {	34,060,685✔
277	return TSDB_CODE_INVALID_PARA;	×
278	}
279
280	if (brinBlock->numOfRecords == 0) { // the first row	34,061,604✔
281	brinBlock->numOfPKs = record->firstKey.key.numOfPKs;	669,752✔
282	} else if (brinBlock->numOfPKs != record->firstKey.key.numOfPKs) {	33,390,941✔
283	// if the number of primary keys are not the same,
284	// return an error code and the caller should handle it
UNCOV 285	return TSDB_CODE_INVALID_PARA;	×
286	} else {
287	for (int i = 0; i < brinBlock->numOfPKs; i++) {	33,393,257✔
288	if (record->firstKey.key.pks[i].type != brinBlock->firstKeyPKs[i].type) {	2,022✔
289	return TSDB_CODE_INVALID_PARA;	×
290	}
291	}
292	}
293
294	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->suids, record->suid));	68,119,560✔
295	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->uids, record->uid));	68,118,748✔
296	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyTimestamps, record->firstKey.key.ts));	68,115,844✔
297	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyVersions, record->firstKey.version));	68,112,960✔
298	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyTimestamps, record->lastKey.key.ts));	68,111,574✔
299	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyVersions, record->lastKey.version));	68,109,350✔
300	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->minVers, record->minVer));	68,110,424✔
301	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->maxVers, record->maxVer));	68,112,281✔
302	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->blockOffsets, record->blockOffset));	68,106,871✔
303	TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->smaOffsets, record->smaOffset));	68,103,865✔
304	TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockSizes, record->blockSize));	68,106,616✔
305	TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockKeySizes, record->blockKeySize));	68,108,882✔
306	TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->smaSizes, record->smaSize));	68,105,568✔
307	TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->numRows, record->numRow));	68,102,910✔
308	TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->counts, record->count));	68,106,874✔
309
310	if (brinBlock->numOfPKs > 0) {	34,054,552✔
311	for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) {	7,774✔
312	TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->firstKeyPKs[i], &record->firstKey.key.pks[i]));	3,887✔
313	}
314
315	for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) {	7,774✔
316	TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->lastKeyPKs[i], &record->lastKey.key.pks[i]));	3,887✔
317	}
318	}
319
320	brinBlock->numOfRecords++;	34,053,821✔
321
322	return 0;	34,055,839✔
323	}
324
325	int32_t tBrinBlockGet(SBrinBlock brinBlock, int32_t idx, SBrinRecord record) {	115,084,791✔
326	SBufferReader reader;	115,084,791✔
327
328	if (idx < 0 \|\| idx >= brinBlock->numOfRecords) {	115,086,537✔
329	return TSDB_CODE_OUT_OF_RANGE;	×
330	}
331
332	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->suids);	115,088,869✔
333	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));	115,088,254✔
334
335	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->uids);	115,084,617✔
336	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));	115,087,330✔
337
338	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyTimestamps);	115,086,920✔
339	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.key.ts));	115,082,170✔
340
341	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyVersions);	115,084,329✔
342	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.version));	115,083,283✔
343
344	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyTimestamps);	115,082,100✔
345	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.key.ts));	115,086,432✔
346
347	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyVersions);	115,079,283✔
348	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.version));	115,078,642✔
349
350	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->minVers);	115,084,063✔
351	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->minVer));	115,083,632✔
352
353	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->maxVers);	115,084,699✔
354	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->maxVer));	115,085,992✔
355
356	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->blockOffsets);	115,082,921✔
357	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->blockOffset));	115,084,089✔
358
359	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->smaOffsets);	115,084,258✔
360	TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->smaOffset));	115,084,096✔
361
362	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockSizes);	115,080,846✔
363	TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockSize));	115,083,049✔
364
365	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockKeySizes);	115,080,021✔
366	TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockKeySize));	115,085,300✔
367
368	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->smaSizes);	115,087,183✔
369	TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->smaSize));	115,083,982✔
370
371	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->numRows);	115,082,020✔
372	TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->numRow));	115,082,595✔
373
374	reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->counts);	115,077,531✔
375	TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->count));	115,078,824✔
376
377	// primary keys
378	for (record->firstKey.key.numOfPKs = 0; record->firstKey.key.numOfPKs < brinBlock->numOfPKs;	115,093,836✔
379	record->firstKey.key.numOfPKs++) {	9,122✔
380	TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->firstKeyPKs[record->firstKey.key.numOfPKs], idx,	9,122✔
381	&record->firstKey.key.pks[record->firstKey.key.numOfPKs]));
382	}
383
384	for (record->lastKey.key.numOfPKs = 0; record->lastKey.key.numOfPKs < brinBlock->numOfPKs;	115,090,692✔
385	record->lastKey.key.numOfPKs++) {	9,122✔
386	TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->lastKeyPKs[record->lastKey.key.numOfPKs], idx,	9,122✔
387	&record->lastKey.key.pks[record->lastKey.key.numOfPKs]));
388	}
389
390	return 0;	115,078,743✔
391	}
392
393	// other apis ----------
394	int32_t tsdbUpdateSkmTb(STsdb pTsdb, const TABLEID tbid, SSkmInfo *pSkmTb) {	70,390,923✔
395	if (tbid->suid) {	70,390,923✔
396	if (pSkmTb->suid == tbid->suid) {	52,524,454✔
397	pSkmTb->uid = tbid->uid;	35,790,523✔
398	return 0;	35,790,188✔
399	}
400	} else if (pSkmTb->uid == tbid->uid) {	17,886,871✔
401	return 0;	228,679✔
402	}
403
404	pSkmTb->suid = tbid->suid;	34,413,764✔
405	pSkmTb->uid = tbid->uid;	34,414,257✔
406	tDestroyTSchema(pSkmTb->pTSchema);	34,419,488✔
407	return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, -1, &pSkmTb->pTSchema);	34,413,551✔
408	}
409
410	int32_t tsdbUpdateSkmRow(STsdb pTsdb, const TABLEID tbid, int32_t sver, SSkmInfo *pSkmRow) {	2,147,483,647✔
411	if (pSkmRow->pTSchema && pSkmRow->suid == tbid->suid) {	2,147,483,647✔
412	if (pSkmRow->suid) {	2,147,483,647✔
413	if (sver == pSkmRow->pTSchema->version) return 0;	2,147,483,647✔
414	} else if (pSkmRow->uid == tbid->uid && pSkmRow->pTSchema->version == sver) {	1,196,750,562✔
415	return 0;	1,188,345,492✔
416	}
417	}
418
419	pSkmRow->suid = tbid->suid;	35,780,588✔
420	pSkmRow->uid = tbid->uid;	33,765,316✔
421	tDestroyTSchema(pSkmRow->pTSchema);	33,769,084✔
422	return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, sver, &pSkmRow->pTSchema);	33,767,025✔
423	}
424	int32_t tsdbUpdateColCmprObj(STsdb pTsdb, const TABLEID tbid, SHashObj **ppColCmpr) { return 0; }	×

taosdata / TDengine / #4908

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