taosdata/TDengine | Build 3565 | source/dnode/vnode/src/tsdb/tsdbRead2.c | Coveralls

UNCOV

FORCE_INLINE int32_t pkCompEx(SRowKey* p1, SRowKey* p2) {

×

UNCOV

94

  if (p2 == NULL) {

×

UNCOV

95

    return 1;

×

UNCOV

98

  if (p1 == NULL) {

×

99

    return -1;

×

UNCOV

102

  if (p1->ts < p2->ts) {

×

UNCOV

103

    return -1;

×

UNCOV

104

  } else if (p1->ts > p2->ts) {

×

UNCOV

105

    return 1;

×

UNCOV

108

  if (p1->numOfPKs == 0) {

×

UNCOV

109

    return 0;

×

UNCOV

111

    return tRowKeyCompare(p1, p2);

×

UNCOV

115

static int32_t tColRowGetPriamyKeyDeepCopy(SBlockData* pBlock, int32_t irow, int32_t slotId, SRowKey* pKey) {

×

UNCOV

116

  int32_t   code = TSDB_CODE_SUCCESS;

×

UNCOV

117

  int32_t   lino = 0;

×

UNCOV

118

  SColData* pColData = NULL;

×

UNCOV

121

  TSDB_CHECK_CONDITION((pBlock != NULL) && (pBlock->aColData != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

122

  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

124

  pColData = &pBlock->aColData[slotId];

×

UNCOV

126

  tColDataGetValue(pColData, irow, &cv);

×

UNCOV

128

  pKey->numOfPKs = 1;

×

UNCOV

129

  pKey->pks[0].type = cv.value.type;

×

UNCOV

131

  if (IS_NUMERIC_TYPE(cv.value.type)) {

×

UNCOV

132

    pKey->pks[0].val = cv.value.val;

×

UNCOV

134

    pKey->pks[0].nData = cv.value.nData;

×

UNCOV

135

    TAOS_MEMCPY(pKey->pks[0].pData, cv.value.pData, cv.value.nData);

×

UNCOV

138

_end:

×

UNCOV

139

  if (code != TSDB_CODE_SUCCESS) {

×

140

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

142

  return code;

×

UNCOV

146

static int32_t tGetPrimaryKeyIndex(uint8_t* p, SPrimaryKeyIndex* index) {

×

UNCOV

147

  int32_t n = 0;

×

UNCOV

148

  n += tGetI8(p + n, &index->type);

×

UNCOV

149

  n += tGetU32v(p + n, &index->offset);

×

UNCOV

150

  return n;

×

UNCOV

153

static int32_t tRowGetPrimaryKeyDeepCopy(SRow* pRow, SRowKey* pKey) {

×

UNCOV

154

  int32_t          code = TSDB_CODE_SUCCESS;

×

UNCOV

155

  int32_t          lino = 0;

×

UNCOV

157

  uint8_t*         data = NULL;

×

UNCOV

158

  int32_t          len = 0;

×

UNCOV

160

  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

161

  if (pRow->numOfPKs > 0) {

×

UNCOV

162

    TSDB_CHECK_NULL(pRow->data, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

163

    TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

166

  data = pRow->data;

×

UNCOV

167

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

×

UNCOV

168

    data += tGetPrimaryKeyIndex(data, &indices[i]);

×

UNCOV

172

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

×

UNCOV

173

    pKey->pks[i].type = indices[i].type;

×

UNCOV

175

    uint8_t* tdata = data + indices[i].offset;

×

UNCOV

176

    if (pRow->flag >> 4) {

×

UNCOV

177

      tdata += tGetI16v(tdata, NULL);

×

UNCOV

180

    if (IS_VAR_DATA_TYPE(indices[i].type)) {

×

UNCOV

181

      tdata += tGetU32v(tdata, &pKey->pks[i].nData);

×

UNCOV

182

      TAOS_MEMCPY(pKey->pks[i].pData, tdata, pKey->pks[i].nData);

×

UNCOV

184

      TAOS_MEMCPY(&pKey->pks[i].val, data + indices[i].offset, tDataTypes[pKey->pks[i].type].bytes);

×

UNCOV

188

_end:

×

UNCOV

189

  if (code != TSDB_CODE_SUCCESS) {

×

190

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

192

  return code;

×

UNCOV

195

static int32_t setColumnIdSlotList(SBlockLoadSuppInfo* pSupInfo, SColumnInfo* pCols, const int32_t* pSlotIdList,

×

UNCOV

197

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

198

  int32_t lino = 0;

×

UNCOV

200

  TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

201

  if (numOfCols > 0) {

×

UNCOV

202

    TSDB_CHECK_NULL(pSlotIdList, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

203

    TSDB_CHECK_NULL(pCols, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

206

  pSupInfo->pk.pk = 0;

×

UNCOV

207

  pSupInfo->numOfPks = 0;

×

UNCOV

208

  pSupInfo->pkSrcSlot = -1;

×

UNCOV

209

  pSupInfo->pkDstSlot = -1;

×

UNCOV

210

  pSupInfo->smaValid = true;

×

UNCOV

211

  pSupInfo->numOfCols = numOfCols;

×

UNCOV

213

  pSupInfo->colId = taosMemoryCalloc(numOfCols, sizeof(int16_t) * 2 + POINTER_BYTES);

×

UNCOV

214

  TSDB_CHECK_NULL(pSupInfo->colId, code, lino, _end, terrno);

×

UNCOV

216

  pSupInfo->slotId = (int16_t*)((char*)pSupInfo->colId + (sizeof(int16_t) * numOfCols));

×

UNCOV

217

  pSupInfo->buildBuf = (char**)((char*)pSupInfo->slotId + (sizeof(int16_t) * numOfCols));

×

UNCOV

218

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

×

UNCOV

219

    pSupInfo->colId[i] = pCols[i].colId;

×

UNCOV

220

    pSupInfo->slotId[i] = pSlotIdList[i];

×

UNCOV

222

    if (pCols[i].pk) {

×

UNCOV

223

      pSupInfo->pk = pCols[i];

×

UNCOV

224

      pSupInfo->pkSrcSlot = i - 1;

×

UNCOV

225

      pSupInfo->pkDstSlot = pSlotIdList[i];

×

UNCOV

226

      pSupInfo->numOfPks += 1;

×

UNCOV

229

    if (IS_VAR_DATA_TYPE(pCols[i].type)) {

×

UNCOV

230

      pSupInfo->buildBuf[i] = taosMemoryMalloc(pCols[i].bytes);

×

UNCOV

231

      if (pSupInfo->buildBuf[i] == NULL) {

×

232

        tsdbError("failed to prepare memory for set columnId slot list, size:%d, code: %s", pCols[i].bytes,

×

UNCOV

235

      TSDB_CHECK_NULL(pSupInfo->buildBuf[i], code, lino, _end, terrno);

×

UNCOV

237

      pSupInfo->buildBuf[i] = NULL;

×

UNCOV

241

_end:

×

UNCOV

242

  if (code != TSDB_CODE_SUCCESS) {

×

243

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

245

  return code;

×

UNCOV

248

static int32_t updateBlockSMAInfo(STSchema* pSchema, SBlockLoadSuppInfo* pSupInfo) {

×

UNCOV

249

  int32_t   code = TSDB_CODE_SUCCESS;

×

UNCOV

250

  int32_t   lino = 0;

×

UNCOV

251

  int32_t   i = 0, j = 0;

×

UNCOV

252

  STColumn* pTCol = NULL;

×

UNCOV

254

  TSDB_CHECK_NULL(pSchema, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

255

  TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

257

  while (i < pSchema->numOfCols && j < pSupInfo->numOfCols) {

×

UNCOV

258

    pTCol = &pSchema->columns[i];

×

UNCOV

259

    if (pTCol->colId == pSupInfo->colId[j]) {

×

UNCOV

260

      if (!IS_BSMA_ON(pTCol) && (PRIMARYKEY_TIMESTAMP_COL_ID != pTCol->colId)) {

×

UNCOV

261

        pSupInfo->smaValid = false;

×

UNCOV

262

        goto _end;

×

UNCOV

265

      i += 1;

×

UNCOV

266

      j += 1;

×

UNCOV

267

    } else if (pTCol->colId < pSupInfo->colId[j]) {  // do nothing

×

UNCOV

268

      i += 1;

×

270

      code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;

×

271

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

275

_end:

×

UNCOV

276

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

277

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

279

  return code;

×

UNCOV

282

static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {

×

UNCOV

283

  return (pWindow == NULL) || (pWindow->skey > pWindow->ekey);

×

UNCOV

288

static int32_t updateQueryTimeWindow(STsdb* pTsdb, STimeWindow* pWindow, STimeWindow* out) {

×

UNCOV

289

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

290

  int32_t lino = 0;

×

UNCOV

291

  int64_t earlyTs = 0;

×

UNCOV

293

  TSDB_CHECK_NULL(pTsdb, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

294

  TSDB_CHECK_NULL(pWindow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

295

  TSDB_CHECK_NULL(out, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

297

  earlyTs = tsdbGetEarliestTs(pTsdb);

×

UNCOV

298

  *out = *pWindow;

×

UNCOV

299

  if (out->skey < earlyTs) {

×

UNCOV

300

    out->skey = earlyTs;

×

UNCOV

303

_end:

×

UNCOV

304

  if (code != TSDB_CODE_SUCCESS) {

×

305

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

307

  return code;

×

UNCOV

311

static int32_t initFilesetIterator(SFilesetIter* pIter, TFileSetArray* pFileSetArray, STsdbReader* pReader) {

×

UNCOV

312

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

313

  int32_t             lino = 0;

×

UNCOV

314

  SBlockLoadSuppInfo* pInfo = NULL;

×

UNCOV

315

  SSttBlockReader*    pSttReader = NULL;

×

UNCOV

316

  size_t              numOfFileset = 0;

×

UNCOV

317

  bool                asc = false;

×

UNCOV

319

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

320

  TSDB_CHECK_NULL(pFileSetArray, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

321

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

323

  pInfo = &pReader->suppInfo;

×

UNCOV

324

  numOfFileset = TARRAY2_SIZE(pFileSetArray);

×

UNCOV

325

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

327

  pIter->index = asc ? -1 : numOfFileset;

×

UNCOV

328

  pIter->order = pReader->info.order;

×

UNCOV

329

  pIter->pFilesetList = pFileSetArray;

×

UNCOV

330

  pIter->numOfFiles = numOfFileset;

×

UNCOV

332

  if (pIter->pSttBlockReader == NULL) {

×

UNCOV

333

    pIter->pSttBlockReader = taosMemoryCalloc(1, sizeof(struct SSttBlockReader));

×

UNCOV

334

    if (pIter->pSttBlockReader == NULL) {

×

335

      tsdbError("failed to prepare the last block iterator, since:%s %s", tstrerror(terrno), pReader->idStr);

×

UNCOV

337

    TSDB_CHECK_NULL(pIter->pSttBlockReader, code, lino, _end, terrno);

×

UNCOV

340

  pSttReader = pIter->pSttBlockReader;

×

UNCOV

341

  pSttReader->order = pReader->info.order;

×

UNCOV

342

  pSttReader->window = pReader->info.window;

×

UNCOV

343

  pSttReader->verRange = pReader->info.verRange;

×

UNCOV

344

  pSttReader->numOfPks = pReader->suppInfo.numOfPks;

×

UNCOV

345

  pSttReader->uid = 0;

×

UNCOV

347

  tMergeTreeClose(&pSttReader->mergeTree);

×

UNCOV

348

  code = initRowKey(&pSttReader->currentKey, INT64_MIN, pInfo->numOfPks, pInfo->pk.type, pInfo->pk.bytes, asc);

×

UNCOV

349

  if (code != TSDB_CODE_SUCCESS) {

×

350

    tsdbError("failed init row key, %s", pReader->idStr);

×

UNCOV

352

    tsdbDebug("init fileset iterator, total files:%d %s", pIter->numOfFiles, pReader->idStr);

×

UNCOV

354

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

356

_end:

×

UNCOV

357

  if (code != TSDB_CODE_SUCCESS) {

×

358

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

360

  return code;

×

UNCOV

363

static int32_t filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader, bool* hasNext) {

×

UNCOV

364

  int32_t           code = TSDB_CODE_SUCCESS;

×

UNCOV

365

  int32_t           lino = 0;

×

UNCOV

366

  bool              asc = false;

×

UNCOV

367

  int32_t           step = 0;

×

UNCOV

368

  SReadCostSummary* pCost = NULL;

×

UNCOV

369

  STFileObj**       pFileObj = NULL;

×

UNCOV

371

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

372

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

373

  TSDB_CHECK_NULL(hasNext, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

375

  asc = ASCENDING_TRAVERSE(pIter->order);

×

UNCOV

376

  step = asc ? 1 : -1;

×

UNCOV

377

  *hasNext = false;

×

UNCOV

379

  pIter->index += step;

×

UNCOV

380

  if ((asc && pIter->index >= pIter->numOfFiles) || ((!asc) && pIter->index < 0)) {

×

UNCOV

381

    *hasNext = false;

×

UNCOV

382

    goto _end;

×

UNCOV

385

  pCost = &pReader->cost;

×

UNCOV

387

  TSDB_CHECK_NULL(pIter->pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

388

  pIter->pSttBlockReader->uid = 0;

×

UNCOV

389

  tMergeTreeClose(&pIter->pSttBlockReader->mergeTree);

×

UNCOV

390

  destroySttBlockReader(pReader->status.pLDataIterArray, &pCost->sttCost);

×

UNCOV

392

  pReader->status.pLDataIterArray = taosArrayInit(4, POINTER_BYTES);

×

UNCOV

393

  TSDB_CHECK_NULL(pReader->status.pLDataIterArray, code, lino, _end, terrno);

×

UNCOV

396

  STimeWindow win = {0};

×

UNCOV

398

  while (1) {

×

UNCOV

399

    if (pReader->pFileReader != NULL) {

×

UNCOV

400

      tsdbDataFileReaderClose(&pReader->pFileReader);

×

UNCOV

403

    TSDB_CHECK_CONDITION(pIter->index < pIter->pFilesetList->size, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);

×

UNCOV

404

    pReader->status.pCurrentFileset = pIter->pFilesetList->data[pIter->index];

×

UNCOV

406

    pFileObj = pReader->status.pCurrentFileset->farr;

×

UNCOV

407

    if (pFileObj[0] != NULL || pFileObj[3] != NULL) {

×

UNCOV

408

      SDataFileReaderConfig conf = {.tsdb = pReader->pTsdb, .szPage = pReader->pTsdb->pVnode->config.tsdbPageSize};

×

UNCOV

410

      const char* filesName[4] = {0};

×

UNCOV

412

      if (pFileObj[0] != NULL) {

×

UNCOV

413

        conf.files[0].file = *pFileObj[0]->f;

×

UNCOV

414

        conf.files[0].exist = true;

×

UNCOV

415

        filesName[0] = pFileObj[0]->fname;

×

UNCOV

417

        conf.files[1].file = *pFileObj[1]->f;

×

UNCOV

418

        conf.files[1].exist = true;

×

UNCOV

419

        filesName[1] = pFileObj[1]->fname;

×

UNCOV

421

        conf.files[2].file = *pFileObj[2]->f;

×

UNCOV

422

        conf.files[2].exist = true;

×

UNCOV

423

        filesName[2] = pFileObj[2]->fname;

×

UNCOV

426

      if (pFileObj[3] != NULL) {

×

UNCOV

427

        conf.files[3].exist = true;

×

UNCOV

428

        conf.files[3].file = *pFileObj[3]->f;

×

UNCOV

429

        filesName[3] = pFileObj[3]->fname;

×

UNCOV

432

      code = tsdbDataFileReaderOpen(filesName, &conf, &pReader->pFileReader);

×

UNCOV

433

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

435

      pReader->cost.headFileLoad += 1;

×

UNCOV

438

    int32_t fid = pReader->status.pCurrentFileset->fid;

×

UNCOV

439

    tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &win.skey, &win.ekey);

×

UNCOV

442

    if ((asc && win.skey > pReader->info.window.ekey) || (!asc && win.ekey < pReader->info.window.skey)) {

×

UNCOV

443

      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, %s", pReader,

×

UNCOV

445

      *hasNext = false;

×

UNCOV

446

      break;

×

UNCOV

449

    if ((asc && (win.ekey < pReader->info.window.skey)) || ((!asc) && (win.skey > pReader->info.window.ekey))) {

×

UNCOV

450

      pIter->index += step;

×

UNCOV

451

      if ((asc && pIter->index >= pIter->numOfFiles) || ((!asc) && pIter->index < 0)) {

×

UNCOV

452

        *hasNext = false;

×

UNCOV

453

        break;

×

UNCOV

455

      continue;

×

UNCOV

458

    tsdbDebug("%p file found fid:%d for qrange:%" PRId64 "-%" PRId64 ", %s", pReader, fid, pReader->info.window.skey,

×

UNCOV

461

    *hasNext = true;

×

UNCOV

462

    break;

×

UNCOV

465

_end:

×

UNCOV

466

  if (code != TSDB_CODE_SUCCESS) {

×

467

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

469

  return code;

×

UNCOV

472

bool shouldFreePkBuf(SBlockLoadSuppInfo* pSupp) {

×

UNCOV

473

  return (pSupp != NULL) && (pSupp->numOfPks > 0) && IS_VAR_DATA_TYPE(pSupp->pk.type);

×

UNCOV

476

int32_t resetDataBlockIterator(SDataBlockIter* pIter, int32_t order, bool needFree, const char* id) {

×

UNCOV

477

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

478

  int32_t lino = 0;

×

UNCOV

480

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

482

  pIter->order = order;

×

UNCOV

483

  pIter->index = -1;

×

UNCOV

484

  pIter->numOfBlocks = 0;

×

UNCOV

486

  if (pIter->blockList == NULL) {

×

UNCOV

487

    pIter->blockList = taosArrayInit(4, sizeof(SFileDataBlockInfo));

×

UNCOV

488

    if (pIter->blockList == NULL) {

×

489

      tsdbError("%s failed to reset block iter, func:%s at line:%d code:%s", id, __func__, __LINE__, tstrerror(terrno));

×

UNCOV

491

    TSDB_CHECK_NULL(pIter->blockList, code, lino, _end, terrno);

×

UNCOV

493

    clearDataBlockIterator(pIter, needFree);

×

UNCOV

496

_end:

×

UNCOV

497

  if (code != TSDB_CODE_SUCCESS) {

×

498

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

500

  return code;

×

UNCOV

503

static void initReaderStatus(SReaderStatus* pStatus) {

×

UNCOV

504

  if (pStatus == NULL) {

×

505

    return;

×

UNCOV

507

  pStatus->pTableIter = NULL;

×

UNCOV

508

  pStatus->loadFromFile = true;

×

UNCOV

511

static int32_t createResBlock(SQueryTableDataCond* pCond, int32_t capacity, SSDataBlock** pResBlock) {

×

UNCOV

512

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

513

  int32_t      lino = 0;

×

UNCOV

514

  SSDataBlock* pBlock = NULL;

×

UNCOV

516

  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

517

  TSDB_CHECK_CONDITION(capacity >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

518

  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

520

  code = createDataBlock(&pBlock);

×

UNCOV

521

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

523

  for (int32_t i = 0; i < pCond->numOfCols; ++i) {

×

UNCOV

524

    SColumnInfoData colInfo = {0};

×

UNCOV

525

    colInfo.info = pCond->colList[i];

×

UNCOV

526

    code = blockDataAppendColInfo(pBlock, &colInfo);

×

UNCOV

527

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

530

  code = blockDataEnsureCapacity(pBlock, capacity);

×

UNCOV

531

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

533

  *pResBlock = pBlock;

×

UNCOV

534

  pBlock = NULL;

×

UNCOV

536

_end:

×

UNCOV

537

  if (code != TSDB_CODE_SUCCESS) {

×

538

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

540

  if (pBlock) {

×

541

    taosArrayDestroy(pBlock->pDataBlock);

×

542

    taosMemoryFreeClear(pBlock);

×

UNCOV

544

  return code;

×

UNCOV

547

static int32_t tsdbInitReaderLock(STsdbReader* pReader) {

×

UNCOV

548

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

549

  int32_t lino = 0;

×

UNCOV

551

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

553

  code = taosThreadMutexInit(&pReader->readerMutex, NULL);

×

UNCOV

554

  tsdbTrace("tsdb/read: %p, post-init read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);

×

UNCOV

555

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

557

_end:

×

UNCOV

558

  if (code != TSDB_CODE_SUCCESS) {

×

559

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

561

  return code;

×

UNCOV

564

static int32_t tsdbUninitReaderLock(STsdbReader* pReader) {

×

UNCOV

565

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

566

  int32_t lino = 0;

×

UNCOV

568

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

570

  tsdbTrace("tsdb/read: %p, pre-uninit read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);

×

UNCOV

571

  code = taosThreadMutexDestroy(&pReader->readerMutex);

×

UNCOV

572

  tsdbTrace("tsdb/read: %p, post-uninit read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);

×

UNCOV

573

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

575

_end:

×

UNCOV

576

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

577

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

579

  return code;

×

UNCOV

582

static int32_t tsdbAcquireReader(STsdbReader* pReader) {

×

UNCOV

583

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

584

  int32_t lino = 0;

×

UNCOV

586

  TSDB_CHECK_CONDITION((pReader != NULL) && (pReader->idStr != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

588

  tsdbTrace("tsdb/read: %s, pre-take read mutex: %p, code: %d", pReader->idStr, &pReader->readerMutex, code);

×

UNCOV

589

  code = taosThreadMutexLock(&pReader->readerMutex);

×

UNCOV

590

  if (code != TSDB_CODE_SUCCESS) {

×

591

    tsdbError("tsdb/read:%p, failed to lock reader mutex, code:%s", pReader->idStr, tstrerror(code));

×

UNCOV

593

    tsdbTrace("tsdb/read: %s, post-take read mutex: %p, code: %d", pReader->idStr, &pReader->readerMutex, code);

×

UNCOV

595

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

597

_end:

×

UNCOV

598

  if (code != TSDB_CODE_SUCCESS) {

×

599

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

601

  return code;

×

604

static int32_t tsdbTryAcquireReader(STsdbReader* pReader) {

×

605

  int32_t code = TSDB_CODE_SUCCESS;

×

606

  int32_t lino = 0;

×

608

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

610

  code = taosThreadMutexTryLock(&pReader->readerMutex);

×

611

  if (code != TSDB_CODE_SUCCESS) {

×

612

    tsdbError("tsdb/read: %p, post-trytake read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);

×

614

    tsdbTrace("tsdb/read: %p, post-trytask read mutex: %p", pReader, &pReader->readerMutex);

×

616

  TSDB_CHECK_CODE(code, lino, _end);

×

618

_end:

×

619

  if (code != TSDB_CODE_SUCCESS) {

×

620

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

622

  return code;

×

UNCOV

625

static int32_t tsdbReleaseReader(STsdbReader* pReader) {

×

UNCOV

626

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

627

  int32_t lino = 0;

×

UNCOV

629

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

631

  code = taosThreadMutexUnlock(&pReader->readerMutex);

×

UNCOV

632

  if (code != TSDB_CODE_SUCCESS) {

×

633

    tsdbError("tsdb/read: %p post-untake read mutex:%p failed, code:%d", pReader, &pReader->readerMutex, code);

×

UNCOV

635

    tsdbTrace("tsdb/read: %p, post-untake read mutex: %p", pReader, &pReader->readerMutex);

×

UNCOV

637

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

639

_end:

×

UNCOV

640

  if (code != TSDB_CODE_SUCCESS) {

×

641

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

643

  return code;

×

UNCOV

646

void tsdbReleaseDataBlock2(STsdbReader* pReader) {

×

UNCOV

647

  if (pReader == NULL) return;

×

UNCOV

649

  SReaderStatus* pStatus = &pReader->status;

×

UNCOV

650

  if (!pStatus->composedDataBlock) {

×

UNCOV

651

    (void) tsdbReleaseReader(pReader);

×

UNCOV

655

static int32_t initResBlockInfo(SResultBlockInfo* pResBlockInfo, int64_t capacity, SSDataBlock* pResBlock,

×

UNCOV

657

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

658

  int32_t      lino = 0;

×

UNCOV

659

  SSDataBlock* p = NULL;

×

UNCOV

661

  TSDB_CHECK_NULL(pResBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

662

  TSDB_CHECK_CONDITION((pResBlockInfo->pResBlock != NULL) || (pSup != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

664

  pResBlockInfo->capacity = capacity;

×

UNCOV

665

  pResBlockInfo->pResBlock = pResBlock;

×

UNCOV

667

  if (pResBlockInfo->pResBlock == NULL) {

×

UNCOV

668

    pResBlockInfo->freeBlock = true;

×

UNCOV

669

    pResBlockInfo->pResBlock = NULL;

×

UNCOV

671

    code = createResBlock(pCond, pResBlockInfo->capacity, &pResBlockInfo->pResBlock);

×

UNCOV

672

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

674

    if (pSup->numOfPks > 0) {

×

UNCOV

675

      p = pResBlockInfo->pResBlock;

×

UNCOV

676

      p->info.pks[0].type = pSup->pk.type;

×

UNCOV

677

      p->info.pks[1].type = pSup->pk.type;

×

UNCOV

679

      if (IS_VAR_DATA_TYPE(pSup->pk.type)) {

×

UNCOV

680

        p->info.pks[0].pData = taosMemoryCalloc(1, pSup->pk.bytes);

×

UNCOV

681

        TSDB_CHECK_NULL(p->info.pks[0].pData, code, lino, _end, terrno);

×

UNCOV

683

        p->info.pks[1].pData = taosMemoryCalloc(1, pSup->pk.bytes);

×

UNCOV

684

        TSDB_CHECK_NULL(p->info.pks[0].pData, code, lino, _end, terrno);

×

UNCOV

686

        p->info.pks[0].nData = pSup->pk.bytes;

×

UNCOV

687

        p->info.pks[1].nData = pSup->pk.bytes;

×

UNCOV

691

    pResBlockInfo->freeBlock = false;

×

UNCOV

694

_end:

×

UNCOV

695

  if (code != TSDB_CODE_SUCCESS) {

×

696

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

698

  return code;

×

UNCOV

701

static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, void** ppReader, int32_t capacity,

×

UNCOV

703

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

704

  int32_t             lino = 0;

×

UNCOV

705

  int8_t              level = 0;

×

UNCOV

706

  STsdbReader*        pReader = NULL;

×

UNCOV

707

  SBlockLoadSuppInfo* pSup = NULL;

×

UNCOV

709

  TSDB_CHECK_NULL(pVnode, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

710

  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

711

  TSDB_CHECK_NULL(ppReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

713

  *ppReader = NULL;

×

UNCOV

714

  pReader = (STsdbReader*)taosMemoryCalloc(1, sizeof(*pReader));

×

UNCOV

715

  TSDB_CHECK_NULL(pReader, code, lino, _end, terrno);

×

UNCOV

717

  if (VND_IS_TSMA(pVnode)) {

×

718

    tsdbDebug("vgId:%d, tsma is selected to query, %s", TD_VID(pVnode), idstr);

×

UNCOV

721

  initReaderStatus(&pReader->status);

×

UNCOV

722

  getTsdbByRetentions(pVnode, pCond, pVnode->config.tsdbCfg.retentions, idstr, &level, &pReader->pTsdb);

×

UNCOV

724

  pReader->info.suid = pCond->suid;

×

UNCOV

725

  pReader->info.order = pCond->order;

×

UNCOV

726

  pReader->info.verRange = getQueryVerRange(pVnode, pCond, level);

×

UNCOV

727

  code = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows, &pReader->info.window);

×

UNCOV

728

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

730

  if (idstr == NULL) {

×

UNCOV

731

    idstr = "";

×

UNCOV

733

  pReader->idStr = taosStrdup(idstr);

×

UNCOV

734

  TSDB_CHECK_NULL(pReader->idStr, code, lino, _end, terrno);

×

UNCOV

736

  pReader->type = pCond->type;

×

UNCOV

737

  pReader->bFilesetDelimited = false;

×

UNCOV

738

  pReader->blockInfoBuf.numPerBucket = 1000;  // 1000 tables per bucket

×

UNCOV

740

  if (pCond->numOfCols <= 0) {

×

741

    tsdbError("vgId:%d, invalid column number %d in query cond, %s", TD_VID(pVnode), pCond->numOfCols, idstr);

×

742

    TSDB_CHECK_CONDITION(pCond->numOfCols > 0, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

746

  pSup = &pReader->suppInfo;

×

UNCOV

747

  pSup->tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;

×

UNCOV

748

  code = setColumnIdSlotList(pSup, pCond->colList, pCond->pSlotList, pCond->numOfCols);

×

UNCOV

749

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

751

  code = initResBlockInfo(&pReader->resBlockInfo, capacity, pResBlock, pCond, pSup);

×

UNCOV

752

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

754

  code = tBlockDataCreate(&pReader->status.fileBlockData);

×

UNCOV

755

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

757

  if (pReader->suppInfo.colId[0] != PRIMARYKEY_TIMESTAMP_COL_ID) {

×

758

    tsdbError("the first column isn't primary timestamp, %d, %s", pReader->suppInfo.colId[0], pReader->idStr);

×

759

    TSDB_CHECK_CONDITION(pReader->suppInfo.colId[0] == PRIMARYKEY_TIMESTAMP_COL_ID, code, lino, _end,

×

UNCOV

763

  pReader->status.pPrimaryTsCol = taosArrayGet(pReader->resBlockInfo.pResBlock->pDataBlock, pSup->slotId[0]);

×

UNCOV

764

  TSDB_CHECK_NULL(pReader->status.pPrimaryTsCol, code, lino, _end, terrno);

×

UNCOV

766

  int32_t type = pReader->status.pPrimaryTsCol->info.type;

×

UNCOV

767

  if (type != TSDB_DATA_TYPE_TIMESTAMP) {

×

768

    tsdbError("the first column isn't primary timestamp in result block, actual: %s, %s", tDataTypes[type].name,

×

770

    TSDB_CHECK_CONDITION(type == TSDB_DATA_TYPE_TIMESTAMP, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

773

  code = tsdbInitReaderLock(pReader);

×

UNCOV

774

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

776

  code = tsem_init(&pReader->resumeAfterSuspend, 0, 0);

×

UNCOV

777

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

779

  *ppReader = pReader;

×

UNCOV

780

  pReader = NULL;

×

UNCOV

782

_end:

×

UNCOV

783

  if (code != TSDB_CODE_SUCCESS) {

×

784

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

786

  if (pReader) {

×

787

    tsdbReaderClose2(pReader);

×

UNCOV

789

  return code;

×

UNCOV

792

static int32_t doLoadBlockIndex(STsdbReader* pReader, SDataFileReader* pFileReader, SArray* pIndexList) {

×

UNCOV

793

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

794

  int32_t              lino = 0;

×

UNCOV

795

  int32_t              st = 0;

×

UNCOV

796

  int32_t              et1 = 0;

×

UNCOV

797

  int32_t              et2 = 0;

×

UNCOV

798

  int32_t              numOfTables = 0;

×

UNCOV

799

  const TBrinBlkArray* pBlkArray = NULL;

×

UNCOV

800

  STableUidList*       pList = NULL;

×

UNCOV

801

  SBrinBlk*            pBrinBlk = NULL;

×

UNCOV

803

  if (pFileReader == NULL) {

×

UNCOV

804

    goto _end;

×

UNCOV

807

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

808

  TSDB_CHECK_NULL(pIndexList, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

810

  st = taosGetTimestampUs();

×

UNCOV

811

  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

813

  code = tsdbDataFileReadBrinBlk(pFileReader, &pBlkArray);

×

UNCOV

814

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

834

  et1 = taosGetTimestampUs();

×

UNCOV

836

  pList = &pReader->status.uidList;

×

UNCOV

838

  int32_t i = 0;

×

UNCOV

839

  int32_t j = 0;

×

UNCOV

840

  while (i < TARRAY2_SIZE(pBlkArray)) {

×

UNCOV

841

    pBrinBlk = &pBlkArray->data[i];

×

UNCOV

842

    if (pBrinBlk->maxTbid.suid < pReader->info.suid) {

×

UNCOV

843

      i += 1;

×

UNCOV

844

      continue;

×

UNCOV

847

    if (pBrinBlk->minTbid.suid > pReader->info.suid) {  // not include the queried table/super table, quit the loop

×

UNCOV

848

      break;

×

UNCOV

851

    TSDB_CHECK_CONDITION(

×

UNCOV

855

    if (pBrinBlk->maxTbid.suid == pReader->info.suid && pBrinBlk->maxTbid.uid < pList->tableUidList[j]) {

×

UNCOV

856

      i += 1;

×

UNCOV

857

      continue;

×

UNCOV

860

    if (pBrinBlk->minTbid.suid == pReader->info.suid && pBrinBlk->minTbid.uid > pList->tableUidList[numOfTables - 1]) {

×

UNCOV

861

      break;

×

UNCOV

864

    const void* p1 = taosArrayPush(pIndexList, pBrinBlk);

×

UNCOV

865

    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

867

    i += 1;

×

UNCOV

868

    if (pBrinBlk->maxTbid.suid == pReader->info.suid) {

×

UNCOV

869

      while (j < numOfTables && pList->tableUidList[j] < pBrinBlk->maxTbid.uid) {

×

UNCOV

870

        j++;

×

UNCOV

872

      if (j >= numOfTables) {

×

UNCOV

873

        break;

×

UNCOV

878

  et2 = taosGetTimestampUs();

×

UNCOV

879

  tsdbDebug("load block index for %d/%d tables completed, elapsed time:%.2f ms, set BrinBlk:%.2f ms, size:%.2f Kb %s",

×

UNCOV

883

  pReader->cost.headFileLoadTime += (et1 - st) / 1000.0;

×

UNCOV

885

_end:

×

UNCOV

886

  if (code != TSDB_CODE_SUCCESS) {

×

887

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

889

  return code;

×

UNCOV

892

static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, SBlockNumber* pBlockNum,

×

UNCOV

894

  int32_t         code = TSDB_CODE_SUCCESS;

×

UNCOV

895

  int32_t         lino = 0;

×

UNCOV

896

  int64_t         st = 0;

×

UNCOV

897

  bool            asc = false;

×

UNCOV

898

  STimeWindow     w = {0};

×

UNCOV

899

  SBrinRecordIter iter = {0};

×

UNCOV

900

  int32_t         numOfTables = 0;

×

UNCOV

901

  SBrinRecord*    pRecord = NULL;

×

UNCOV

902

  int32_t         k = 0;

×

UNCOV

903

  size_t          sizeInDisk = 0;

×

UNCOV

905

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

906

  TSDB_CHECK_NULL(pBlockNum, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

907

  TSDB_CHECK_NULL(pTableScanInfoList, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

909

  st = taosGetTimestampUs();

×

UNCOV

910

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

911

  w = pReader->info.window;

×

UNCOV

912

  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

915

  cleanupInfoForNextFileset(pReader->status.pTableMap);

×

UNCOV

916

  initBrinRecordIter(&iter, pReader->pFileReader, pIndexList);

×

UNCOV

918

  while (1) {

×

UNCOV

919

    code = getNextBrinRecord(&iter, &pRecord);

×

UNCOV

920

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

922

    if (pRecord == NULL) {

×

UNCOV

923

      break;

×

UNCOV

926

    if (pRecord->suid > pReader->info.suid) {

×

UNCOV

927

      break;

×

UNCOV

930

    uint64_t uid = pReader->status.uidList.tableUidList[k];

×

UNCOV

931

    if (pRecord->suid < pReader->info.suid) {

×

UNCOV

932

      continue;

×

UNCOV

935

    if (uid < pRecord->uid) {  // forward the table uid index

×

UNCOV

936

      while (k < numOfTables && pReader->status.uidList.tableUidList[k] < pRecord->uid) {

×

UNCOV

937

        k += 1;

×

UNCOV

940

      if (k >= numOfTables) {

×

UNCOV

941

        break;

×

UNCOV

944

      uid = pReader->status.uidList.tableUidList[k];

×

UNCOV

947

    if (pRecord->uid < uid) {

×

UNCOV

948

      continue;

×

UNCOV

951

    TSDB_CHECK_CONDITION((pRecord->suid == pReader->info.suid) && (uid == pRecord->uid), code, lino, _end,

×

UNCOV

954

    STableBlockScanInfo* pScanInfo = NULL;

×

UNCOV

955

    code = getTableBlockScanInfo(pReader->status.pTableMap, uid, &pScanInfo, pReader->idStr);

×

UNCOV

956

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

960

    if (asc) {

×

UNCOV

961

      w.skey = pScanInfo->lastProcKey.ts;

×

UNCOV

963

      w.ekey = pScanInfo->lastProcKey.ts;

×

UNCOV

967

    if (((w.skey < INT64_MAX) && ((w.skey + 1) > w.ekey)) || (w.skey == INT64_MAX)) {

×

968

      k += 1;

×

969

      if (k >= numOfTables) {

×

970

        break;

×

972

        continue;

×

UNCOV

977

    if (pRecord->firstKey.key.ts > w.ekey || pRecord->lastKey.key.ts < w.skey) {

×

UNCOV

978

      continue;

×

UNCOV

981

    if (asc) {

×

UNCOV

982

      if (pkCompEx(&pRecord->lastKey.key, &pScanInfo->lastProcKey) <= 0) {

×

UNCOV

983

        continue;

×

UNCOV

986

      if (pkCompEx(&pRecord->firstKey.key, &pScanInfo->lastProcKey) >= 0) {

×

987

        continue;

×

UNCOV

992

    if (pRecord->minVer > pReader->info.verRange.maxVer || pRecord->maxVer < pReader->info.verRange.minVer) {

×

UNCOV

993

      continue;

×

UNCOV

996

    if (pScanInfo->pBlockList == NULL) {

×

UNCOV

997

      pScanInfo->pBlockList = taosArrayInit(4, sizeof(SFileDataBlockInfo));

×

UNCOV

998

      TSDB_CHECK_NULL(pScanInfo->pBlockList, code, lino, _end, terrno);

×

UNCOV

1001

    if (pScanInfo->pBlockIdxList == NULL) {

×

UNCOV

1002

      pScanInfo->pBlockIdxList = taosArrayInit(4, sizeof(STableDataBlockIdx));

×

UNCOV

1003

      TSDB_CHECK_NULL(pScanInfo->pBlockIdxList, code, lino, _end, terrno);

×

UNCOV

1006

    SFileDataBlockInfo blockInfo = {.tbBlockIdx = TARRAY_SIZE(pScanInfo->pBlockList)};

×

UNCOV

1007

    code = recordToBlockInfo(&blockInfo, pRecord);

×

UNCOV

1008

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1009

    sizeInDisk += blockInfo.blockSize;

×

UNCOV

1011

    const void* p1 = taosArrayPush(pScanInfo->pBlockList, &blockInfo);

×

UNCOV

1012

    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

1015

    if (pScanInfo->filesetWindow.skey > pRecord->firstKey.key.ts) {

×

UNCOV

1016

      pScanInfo->filesetWindow.skey = pRecord->firstKey.key.ts;

×

UNCOV

1019

    if (pScanInfo->filesetWindow.ekey < pRecord->lastKey.key.ts) {

×

UNCOV

1020

      pScanInfo->filesetWindow.ekey = pRecord->lastKey.key.ts;

×

UNCOV

1023

    pBlockNum->numOfBlocks += 1;

×

UNCOV

1024

    if (taosArrayGetSize(pTableScanInfoList) == 0) {

×

UNCOV

1025

      p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);

×

UNCOV

1026

      TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

1028

      STableBlockScanInfo** p = taosArrayGetLast(pTableScanInfoList);

×

UNCOV

1029

      TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1031

      if ((*p)->uid != uid) {

×

UNCOV

1032

        p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);

×

UNCOV

1033

        TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

1038

  pBlockNum->numOfSttFiles = pReader->status.pCurrentFileset->lvlArr->size;

×

UNCOV

1039

  int32_t total = pBlockNum->numOfSttFiles + pBlockNum->numOfBlocks;

×

UNCOV

1041

  double el = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

1042

  tsdbDebug(

×

UNCOV

1048

  pReader->cost.numOfBlocks += total;

×

UNCOV

1049

  pReader->cost.headFileLoadTime += el;

×

UNCOV

1051

_end:

×

UNCOV

1052

  if (code != TSDB_CODE_SUCCESS) {

×

1053

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1055

  clearBrinBlockIter(&iter);

×

UNCOV

1056

  return code;

×

UNCOV

1059

static void setBlockAllDumped(SFileBlockDumpInfo* pDumpInfo, int64_t maxKey, int32_t order) {

×

UNCOV

1060

  if (pDumpInfo != NULL) {

×

UNCOV

1061

    pDumpInfo->allDumped = true;

×

UNCOV

1063

×

UNCOV

1065

static int32_t updateLastKeyInfo(SRowKey* pKey, SFileDataBlockInfo* pBlockInfo, SDataBlockInfo* pInfo, int32_t numOfPks,

×

UNCOV

1067

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1068

  int32_t lino = 0;

×

UNCOV

1070

  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1071

  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1073

  pKey->ts = asc ? pInfo->window.ekey : pInfo->window.skey;

×

UNCOV

1074

  pKey->numOfPKs = numOfPks;

×

UNCOV

1075

  if (pKey->numOfPKs <= 0) {

×

UNCOV

1076

    goto _end;

×

UNCOV

1079

  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1080

  if (IS_NUMERIC_TYPE(pKey->pks[0].type)) {

×

UNCOV

1081

    pKey->pks[0].val = asc ? pBlockInfo->lastPk.val : pBlockInfo->firstPk.val;

×

1083

    uint8_t* p = asc ? pBlockInfo->lastPk.pData : pBlockInfo->firstPk.pData;

×

1084

    pKey->pks[0].nData = asc ? varDataLen(pBlockInfo->lastPk.pData) : varDataLen(pBlockInfo->firstPk.pData);

×

1085

    TAOS_MEMCPY(pKey->pks[0].pData, p, pKey->pks[0].nData);

×

UNCOV

1088

_end:

×

UNCOV

1089

  if (code != TSDB_CODE_SUCCESS) {

×

1090

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1092

  return code;

×

UNCOV

1095

static int32_t doCopyColVal(SColumnInfoData* pColInfoData, int32_t rowIndex, int32_t colIndex, SColVal* pColVal,

×

UNCOV

1097

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1098

  int32_t lino = 0;

×

UNCOV

1100

  TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1101

  TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1103

  if (IS_VAR_DATA_TYPE(pColVal->value.type)) {

×

UNCOV

1104

    if (!COL_VAL_IS_VALUE(pColVal)) {

×

UNCOV

1105

      colDataSetNULL(pColInfoData, rowIndex);

×

UNCOV

1107

      TSDB_CHECK_NULL(pSup, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1108

      varDataSetLen(pSup->buildBuf[colIndex], pColVal->value.nData);

×

UNCOV

1109

      if ((pColVal->value.nData + VARSTR_HEADER_SIZE) > pColInfoData->info.bytes) {

×

UNCOV

1110

        tsdbWarn("column cid:%d actual data len %d is bigger than schema len %d", pColVal->cid, pColVal->value.nData,

×

UNCOV

1112

        code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;

×

UNCOV

1113

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1116

      if (pColVal->value.nData > 0) {  // pData may be null, if nData is 0

×

UNCOV

1117

        (void)memcpy(varDataVal(pSup->buildBuf[colIndex]), pColVal->value.pData, pColVal->value.nData);

×

UNCOV

1120

      code = colDataSetVal(pColInfoData, rowIndex, pSup->buildBuf[colIndex], false);

×

UNCOV

1121

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1124

    code = colDataSetVal(pColInfoData, rowIndex, (const char*)&pColVal->value.val, !COL_VAL_IS_VALUE(pColVal));

×

UNCOV

1125

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1128

_end:

×

UNCOV

1129

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

1130

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1132

  return code;

×

UNCOV

1135

static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo, const char* id) {

×

UNCOV

1136

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1137

  int32_t lino = 0;

×

UNCOV

1139

  TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1140

  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1141

  TSDB_CHECK_NULL(pBlockIter->blockList, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1143

  *pInfo = NULL;

×

UNCOV

1145

  size_t num = TARRAY_SIZE(pBlockIter->blockList);

×

UNCOV

1146

  if (num == 0) {

×

UNCOV

1149

    TSDB_CHECK_CONDITION(num == pBlockIter->numOfBlocks, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1150

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

1153

  *pInfo = taosArrayGet(pBlockIter->blockList, pBlockIter->index);

×

UNCOV

1154

  TSDB_CHECK_NULL(*pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1156

_end:

×

UNCOV

1157

  if (code != TSDB_CODE_SUCCESS) {

×

1158

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1160

  return code;

×

UNCOV

1163

static int32_t doBinarySearchKey(const TSKEY* keyList, int num, int pos, TSKEY key, int order) {

×

UNCOV

1166

  s = pos;

×

UNCOV

1169

  if (!(keyList != NULL && pos >= 0 && pos < num && num > 0)) {

×

1170

    return -1;

×

UNCOV

1172

  if (order == TSDB_ORDER_ASC) {

×

UNCOV

1174

    e = num - 1;

×

UNCOV

1175

    if (key < keyList[pos]) return -1;

×

UNCOV

1176

    while (1) {

×

UNCOV

1178

      if (key >= keyList[e]) return e;

×

UNCOV

1179

      if (key <= keyList[s]) return s;

×

UNCOV

1180

      if (e - s <= 1) return s;

×

UNCOV

1183

      int mid = s + (e - s + 1) / 2;

×

UNCOV

1184

      if (keyList[mid] > key)

×

UNCOV

1185

        e = mid;

×

UNCOV

1186

      else if (keyList[mid] < key)

×

UNCOV

1187

        s = mid;

×

UNCOV

1189

        return mid;

×

UNCOV

1193

    e = 0;

×

UNCOV

1194

    if (key > keyList[pos]) return -1;

×

UNCOV

1195

    while (1) {

×

UNCOV

1197

      if (key <= keyList[e]) return e;

×

UNCOV

1198

      if (key >= keyList[s]) return s;

×

UNCOV

1199

      if (s - e <= 1) return s;

×

UNCOV

1202

      int mid = s - (s - e + 1) / 2;

×

UNCOV

1203

      if (keyList[mid] < key)

×

UNCOV

1204

        e = mid;

×

UNCOV

1205

      else if (keyList[mid] > key)

×

UNCOV

1206

        s = mid;

×

UNCOV

1208

        return mid;

×

UNCOV

1214

static int32_t findFirstPos(const int64_t* pTsList, int32_t num, int32_t startPos, bool asc) {

×

UNCOV

1215

  int32_t i = startPos;

×

UNCOV

1216

  int64_t startTs = pTsList[startPos];

×

UNCOV

1217

  if (asc) {

×

UNCOV

1218

    while (i < num && (pTsList[i] == startTs)) {

×

UNCOV

1219

      i++;

×

UNCOV

1221

    return i - 1;

×

UNCOV

1223

    while (i >= 0 && (pTsList[i] == startTs)) {

×

UNCOV

1224

      i--;

×

UNCOV

1226

    return i + 1;

×

UNCOV

1230

static int32_t getEndPosInDataBlock(STsdbReader* pReader, SBlockData* pBlockData, SBrinRecord* pRecord, int32_t pos) {

×

UNCOV

1232

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1233

  int32_t lino = 0;

×

UNCOV

1234

  int32_t endPos = -1;

×

UNCOV

1235

  bool    asc = false;

×

UNCOV

1237

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1238

  TSDB_CHECK_NULL(pRecord, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1240

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

1242

  if (asc && pReader->info.window.ekey >= pRecord->lastKey.key.ts) {

×

UNCOV

1243

    endPos = pRecord->numRow - 1;

×

UNCOV

1244

  } else if (!asc && pReader->info.window.skey <= pRecord->firstKey.key.ts) {

×

UNCOV

1245

    endPos = 0;

×

UNCOV

1247

    int64_t key = asc ? pReader->info.window.ekey : pReader->info.window.skey;

×

UNCOV

1248

    endPos = doBinarySearchKey(pBlockData->aTSKEY, pRecord->numRow, pos, key, pReader->info.order);

×

UNCOV

1249

    if (endPos == -1) {

×

UNCOV

1250

      goto _end;

×

UNCOV

1253

    endPos = findFirstPos(pBlockData->aTSKEY, pRecord->numRow, endPos, asc);

×

UNCOV

1256

  if ((pReader->info.verRange.maxVer >= pRecord->minVer && pReader->info.verRange.maxVer < pRecord->maxVer) ||

×

UNCOV

1257

      (pReader->info.verRange.minVer <= pRecord->maxVer && pReader->info.verRange.minVer > pRecord->minVer)) {

×

UNCOV

1258

    int32_t i = endPos;

×

UNCOV

1260

    if (asc) {

×

UNCOV

1261

      for (; i >= 0; --i) {

×

UNCOV

1262

        if (pBlockData->aVersion[i] <= pReader->info.verRange.maxVer) {

×

UNCOV

1263

          break;

×

1267

      for (; i < pRecord->numRow; ++i) {

×

1268

        if (pBlockData->aVersion[i] >= pReader->info.verRange.minVer) {

×

1269

          break;

×

UNCOV

1274

    endPos = i;

×

UNCOV

1277

_end:

×

UNCOV

1278

  if (code != TSDB_CODE_SUCCESS) {

×

1279

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1281

  return endPos;

×

UNCOV

1284

static int32_t copyPrimaryTsCol(const SBlockData* pBlockData, SFileBlockDumpInfo* pDumpInfo, SColumnInfoData* pColData,

×

UNCOV

1286

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1287

  int32_t lino = 0;

×

UNCOV

1289

  TSDB_CHECK_CONDITION((pBlockData != NULL) && (pBlockData->aTSKEY != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1290

  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1291

  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1292

  TSDB_CHECK_CONDITION(dumpedRows >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1294

  if (asc) {

×

UNCOV

1295

    TAOS_MEMCPY(pColData->pData, &pBlockData->aTSKEY[pDumpInfo->rowIndex], dumpedRows * sizeof(int64_t));

×

UNCOV

1297

    int32_t startIndex = pDumpInfo->rowIndex - dumpedRows + 1;

×

UNCOV

1298

    TAOS_MEMCPY(pColData->pData, &pBlockData->aTSKEY[startIndex], dumpedRows * sizeof(int64_t));

×

UNCOV

1302

    int32_t  mid = dumpedRows >> 1u;

×

UNCOV

1303

    int64_t* pts = (int64_t*)pColData->pData;

×

UNCOV

1304

    for (int32_t j = 0; j < mid; ++j) {

×

UNCOV

1305

      int64_t t = pts[j];

×

UNCOV

1306

      pts[j] = pts[dumpedRows - j - 1];

×

UNCOV

1307

      pts[dumpedRows - j - 1] = t;

×

UNCOV

1311

_end:

×

UNCOV

1312

  if (code != TSDB_CODE_SUCCESS) {

×

1313

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1315

  return code;

×

UNCOV

1319

static int32_t copyNumericCols(const SColData* pData, SFileBlockDumpInfo* pDumpInfo, SColumnInfoData* pColData,

×

UNCOV

1321

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

1322

  int32_t  lino = 0;

×

UNCOV

1323

  uint8_t* p = NULL;

×

UNCOV

1324

  int32_t  step = asc ? 1 : -1;

×

UNCOV

1326

  TSDB_CHECK_NULL(pData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1327

  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1328

  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1329

  TSDB_CHECK_CONDITION(dumpedRows >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1331

  TSDB_CHECK_CONDITION(pData->type < TSDB_DATA_TYPE_MAX, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1332

  if (asc) {

×

UNCOV

1333

    p = pData->pData + tDataTypes[pData->type].bytes * pDumpInfo->rowIndex;

×

UNCOV

1335

    int32_t startIndex = pDumpInfo->rowIndex - dumpedRows + 1;

×

UNCOV

1336

    p = pData->pData + tDataTypes[pData->type].bytes * startIndex;

×

UNCOV

1342

  TAOS_MEMCPY(pColData->pData, p, dumpedRows * tDataTypes[pData->type].bytes);

×

UNCOV

1345

  if (!asc) {

×

UNCOV

1346

    switch (pColData->info.type) {

×

UNCOV

1347

      case TSDB_DATA_TYPE_TIMESTAMP:

×

UNCOV

1351

        int32_t  mid = dumpedRows >> 1u;

×

UNCOV

1352

        int64_t* pts = (int64_t*)pColData->pData;

×

UNCOV

1353

        for (int32_t j = 0; j < mid; ++j) {

×

UNCOV

1354

          int64_t t = pts[j];

×

UNCOV

1355

          pts[j] = pts[dumpedRows - j - 1];

×

UNCOV

1356

          pts[dumpedRows - j - 1] = t;

×

UNCOV

1358

        break;

×

UNCOV

1361

      case TSDB_DATA_TYPE_BOOL:

×

UNCOV

1364

        int32_t mid = dumpedRows >> 1u;

×

UNCOV

1365

        int8_t* pts = (int8_t*)pColData->pData;

×

UNCOV

1366

        for (int32_t j = 0; j < mid; ++j) {

×

UNCOV

1367

          int8_t t = pts[j];

×

UNCOV

1368

          pts[j] = pts[dumpedRows - j - 1];

×

UNCOV

1369

          pts[dumpedRows - j - 1] = t;

×

UNCOV

1371

        break;

×

UNCOV

1374

      case TSDB_DATA_TYPE_SMALLINT:

×

UNCOV

1376

        int32_t  mid = dumpedRows >> 1u;

×

UNCOV

1377

        int16_t* pts = (int16_t*)pColData->pData;

×

UNCOV

1378

        for (int32_t j = 0; j < mid; ++j) {

×

UNCOV

1379

          int64_t t = pts[j];

×

UNCOV

1380

          pts[j] = pts[dumpedRows - j - 1];

×

UNCOV

1381

          pts[dumpedRows - j - 1] = t;

×

UNCOV

1383

        break;

×

UNCOV

1386

      case TSDB_DATA_TYPE_FLOAT:

×

UNCOV

1389

        int32_t  mid = dumpedRows >> 1u;

×

UNCOV

1390

        int32_t* pts = (int32_t*)pColData->pData;

×

UNCOV

1391

        for (int32_t j = 0; j < mid; ++j) {

×

UNCOV

1392

          int32_t t = pts[j];

×

UNCOV

1393

          pts[j] = pts[dumpedRows - j - 1];

×

UNCOV

1394

          pts[dumpedRows - j - 1] = t;

×

UNCOV

1396

        break;

×

UNCOV

1402

  if (pData->flag != HAS_VALUE) {

×

UNCOV

1403

    int32_t rowIndex = 0;

×

UNCOV

1405

    for (int32_t j = pDumpInfo->rowIndex; rowIndex < dumpedRows; j += step, rowIndex++) {

×

UNCOV

1406

      uint8_t v = tColDataGetBitValue(pData, j);

×

UNCOV

1407

      if (v == 0 || v == 1) {

×

UNCOV

1408

        colDataSetNull_f(pColData->nullbitmap, rowIndex);

×

UNCOV

1409

        pColData->hasNull = true;

×

UNCOV

1414

_end:

×

UNCOV

1415

  if (code != TSDB_CODE_SUCCESS) {

×

1416

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1418

  return code;

×

UNCOV

1421

static void blockInfoToRecord(SBrinRecord* record, SFileDataBlockInfo* pBlockInfo, SBlockLoadSuppInfo* pSupp) {

×

UNCOV

1422

  record->uid = pBlockInfo->uid;

×

UNCOV

1423

  record->firstKey = (STsdbRowKey){.key = {.ts = pBlockInfo->firstKey, .numOfPKs = pSupp->numOfPks}};

×

UNCOV

1424

  record->lastKey = (STsdbRowKey){.key = {.ts = pBlockInfo->lastKey, .numOfPKs = pSupp->numOfPks}};

×

UNCOV

1426

  if (pSupp->numOfPks > 0) {

×

UNCOV

1427

    SValue* pFirst = &record->firstKey.key.pks[0];

×

UNCOV

1428

    SValue* pLast = &record->lastKey.key.pks[0];

×

UNCOV

1430

    pFirst->type = pSupp->pk.type;

×

UNCOV

1431

    pLast->type = pSupp->pk.type;

×

UNCOV

1433

    if (IS_VAR_DATA_TYPE(pFirst->type)) {

×

1434

      pFirst->pData = (uint8_t*)varDataVal(pBlockInfo->firstPk.pData);

×

1435

      pFirst->nData = varDataLen(pBlockInfo->firstPk.pData);

×

1437

      pLast->pData = (uint8_t*)varDataVal(pBlockInfo->lastPk.pData);

×

1438

      pLast->nData = varDataLen(pBlockInfo->lastPk.pData);

×

UNCOV

1440

      pFirst->val = pBlockInfo->firstPk.val;

×

UNCOV

1441

      pLast->val = pBlockInfo->lastPk.val;

×

UNCOV

1445

  record->minVer = pBlockInfo->minVer;

×

UNCOV

1446

  record->maxVer = pBlockInfo->maxVer;

×

UNCOV

1447

  record->blockOffset = pBlockInfo->blockOffset;

×

UNCOV

1448

  record->smaOffset = pBlockInfo->smaOffset;

×

UNCOV

1449

  record->blockSize = pBlockInfo->blockSize;

×

UNCOV

1450

  record->blockKeySize = pBlockInfo->blockKeySize;

×

UNCOV

1451

  record->smaSize = pBlockInfo->smaSize;

×

UNCOV

1452

  record->numRow = pBlockInfo->numRow;

×

UNCOV

1453

  record->count = pBlockInfo->count;

×

UNCOV

1454

×

UNCOV

1456

static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, SRowKey* pLastProcKey) {

×

UNCOV

1457

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

1458

  int32_t             lino = 0;

×

UNCOV

1459

  SReaderStatus*      pStatus = NULL;

×

UNCOV

1460

  SDataBlockIter*     pBlockIter = NULL;

×

UNCOV

1461

  SBlockLoadSuppInfo* pSupInfo = NULL;

×

UNCOV

1462

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

1463

  SBlockData*         pBlockData = NULL;

×

UNCOV

1464

  SFileDataBlockInfo* pBlockInfo = NULL;

×

UNCOV

1465

  SSDataBlock*        pResBlock = NULL;

×

UNCOV

1466

  int32_t             numOfOutputCols = 0;

×

UNCOV

1467

  int64_t             st = 0;

×

UNCOV

1468

  bool                asc = false;

×

UNCOV

1469

  int32_t             step = 0;

×

UNCOV

1470

  SColVal             cv = {0};

×

UNCOV

1472

  SBrinRecord*        pRecord = NULL;

×

UNCOV

1474

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1476

  pStatus = &pReader->status;

×

UNCOV

1477

  pBlockIter = &pStatus->blockIter;

×

UNCOV

1478

  pSupInfo = &pReader->suppInfo;

×

UNCOV

1479

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

1481

  pBlockData = &pStatus->fileBlockData;

×

UNCOV

1482

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

1483

  numOfOutputCols = pSupInfo->numOfCols;

×

UNCOV

1484

  st = taosGetTimestampUs();

×

UNCOV

1485

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

1486

  step = asc ? 1 : -1;

×

UNCOV

1488

  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

1489

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1491

  blockInfoToRecord(&tmp, pBlockInfo, pSupInfo);

×

UNCOV

1492

  pRecord = &tmp;

×

UNCOV

1495

  if (pBlockData->nRow == 0 || pBlockData->aTSKEY == 0) {

×

1496

    tsdbWarn("%p no need to copy since no data in blockData, table uid:%" PRIu64 " has been dropped, %s", pReader,

×

1498

    pResBlock->info.rows = 0;

×

1499

    goto _end;

×

UNCOV

1502

  TSDB_CHECK_CONDITION((pDumpInfo->rowIndex >= 0) && (pDumpInfo->rowIndex < pRecord->numRow), code, lino, _end,

×

UNCOV

1506

  if (((pDumpInfo->rowIndex == 0) && asc) || ((pDumpInfo->rowIndex == (pRecord->numRow - 1)) && (!asc))) {

×

UNCOV

1507

    if (asc && pReader->info.window.skey <= pRecord->firstKey.key.ts &&

×

UNCOV

1508

        pReader->info.verRange.minVer <= pRecord->minVer) {

×

UNCOV

1510

    } else if (!asc && pReader->info.window.ekey >= pRecord->lastKey.key.ts &&

×

UNCOV

1511

               pReader->info.verRange.maxVer >= pRecord->maxVer) {

×

UNCOV

1514

      int32_t pos = asc ? pRecord->numRow - 1 : 0;

×

UNCOV

1515

      int32_t order = asc ? TSDB_ORDER_DESC : TSDB_ORDER_ASC;

×

UNCOV

1516

      int64_t key = asc ? pReader->info.window.skey : pReader->info.window.ekey;

×

UNCOV

1517

      pDumpInfo->rowIndex = doBinarySearchKey(pBlockData->aTSKEY, pRecord->numRow, pos, key, order);

×

UNCOV

1519

      if (pDumpInfo->rowIndex < 0) {

×

UNCOV

1520

        tsdbError(

×

UNCOV

1525

        code = TSDB_CODE_INVALID_PARA;

×

UNCOV

1526

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1529

      pDumpInfo->rowIndex = findFirstPos(pBlockData->aTSKEY, pRecord->numRow, pDumpInfo->rowIndex, (!asc));

×

UNCOV

1531

      TSDB_CHECK_CONDITION(

×

UNCOV

1536

      if ((pReader->info.verRange.maxVer >= pRecord->minVer && pReader->info.verRange.maxVer < pRecord->maxVer) ||

×

UNCOV

1537

          (pReader->info.verRange.minVer <= pRecord->maxVer && pReader->info.verRange.minVer > pRecord->minVer)) {

×

UNCOV

1538

        int32_t i = pDumpInfo->rowIndex;

×

UNCOV

1539

        if (asc) {

×

UNCOV

1540

          for (; i < pRecord->numRow; ++i) {

×

UNCOV

1541

            if (pBlockData->aVersion[i] >= pReader->info.verRange.minVer) {

×

UNCOV

1542

              break;

×

1546

          for (; i >= 0; --i) {

×

1547

            if (pBlockData->aVersion[i] <= pReader->info.verRange.maxVer) {

×

1548

              break;

×

UNCOV

1553

        pDumpInfo->rowIndex = i;

×

UNCOV

1559

  int32_t endIndex = getEndPosInDataBlock(pReader, pBlockData, pRecord, pDumpInfo->rowIndex);

×

UNCOV

1560

  if (endIndex == -1) {

×

1561

    setBlockAllDumped(pDumpInfo, pReader->info.window.ekey, pReader->info.order);

×

UNCOV

1562

    goto _end;

×

UNCOV

1565

  endIndex += step;

×

UNCOV

1566

  int32_t dumpedRows = asc ? (endIndex - pDumpInfo->rowIndex) : (pDumpInfo->rowIndex - endIndex);

×

UNCOV

1567

  if (dumpedRows > pReader->resBlockInfo.capacity) {  // output buffer check

×

1568

    dumpedRows = pReader->resBlockInfo.capacity;

×

UNCOV

1569

  } else if (dumpedRows <= 0) {  // no qualified rows in current data block, quit directly.

×

UNCOV

1570

    setBlockAllDumped(pDumpInfo, pReader->info.window.ekey, pReader->info.order);

×

UNCOV

1571

    goto _end;

×

UNCOV

1574

  int32_t i = 0;

×

UNCOV

1575

  int32_t rowIndex = 0;

×

UNCOV

1577

  SColumnInfoData* pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

1578

  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1580

  if (pSupInfo->colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {

×

UNCOV

1581

    code = copyPrimaryTsCol(pBlockData, pDumpInfo, pColData, dumpedRows, asc);

×

UNCOV

1582

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1583

    i += 1;

×

UNCOV

1586

  int32_t colIndex = 0;

×

UNCOV

1587

  int32_t num = pBlockData->nColData;

×

UNCOV

1588

  while (i < numOfOutputCols && colIndex < num) {

×

UNCOV

1589

    rowIndex = 0;

×

UNCOV

1591

    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, colIndex);

×

UNCOV

1592

    if (pData->cid < pSupInfo->colId[i]) {

×

1593

      colIndex += 1;

×

UNCOV

1594

    } else if (pData->cid == pSupInfo->colId[i]) {

×

UNCOV

1595

      pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

1596

      TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1598

      if (pData->flag == HAS_NONE || pData->flag == HAS_NULL || pData->flag == (HAS_NULL | HAS_NONE)) {

×

UNCOV

1599

        colDataSetNNULL(pColData, 0, dumpedRows);

×

UNCOV

1601

        if (IS_MATHABLE_TYPE(pColData->info.type)) {

×

UNCOV

1602

          code = copyNumericCols(pData, pDumpInfo, pColData, dumpedRows, asc);

×

UNCOV

1603

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1605

          for (int32_t j = pDumpInfo->rowIndex; rowIndex < dumpedRows; j += step) {

×

UNCOV

1606

            tColDataGetValue(pData, j, &cv);

×

UNCOV

1607

            code = doCopyColVal(pColData, rowIndex++, i, &cv, pSupInfo);

×

UNCOV

1608

            TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1613

      colIndex += 1;

×

UNCOV

1614

      i += 1;

×

1616

      pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

1617

      TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1619

      colDataSetNNULL(pColData, 0, dumpedRows);

×

1620

      i += 1;

×

UNCOV

1625

  while (i < numOfOutputCols) {

×

1626

    pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

1627

    TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1629

    colDataSetNNULL(pColData, 0, dumpedRows);

×

1630

    i += 1;

×

UNCOV

1633

  pResBlock->info.dataLoad = 1;

×

UNCOV

1634

  pResBlock->info.rows = dumpedRows;

×

UNCOV

1635

  pDumpInfo->rowIndex += step * dumpedRows;

×

UNCOV

1637

  tColRowGetKeyDeepCopy(pBlockData, pDumpInfo->rowIndex - step, pSupInfo->pkSrcSlot, pLastProcKey);

×

UNCOV

1640

  if (pDumpInfo->rowIndex >= 0 && pDumpInfo->rowIndex < pRecord->numRow) {

×

UNCOV

1641

    int64_t ts = pBlockData->aTSKEY[pDumpInfo->rowIndex];

×

UNCOV

1644

    if (outOfTimeWindow(ts, &pReader->info.window)) {

×

UNCOV

1645

      setBlockAllDumped(pDumpInfo, ts, pReader->info.order);

×

UNCOV

1648

    int64_t ts = asc ? pRecord->lastKey.key.ts : pRecord->firstKey.key.ts;

×

UNCOV

1649

    setBlockAllDumped(pDumpInfo, ts, pReader->info.order);

×

UNCOV

1652

  double elapsedTime = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

1653

  pReader->cost.blockLoadTime += elapsedTime;

×

UNCOV

1655

  int32_t unDumpedRows = asc ? pRecord->numRow - pDumpInfo->rowIndex : pDumpInfo->rowIndex + 1;

×

UNCOV

1656

  tsdbDebug("%p copy file block to sdatablock, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64

×

UNCOV

1661

_end:

×

UNCOV

1662

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

1663

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1665

  return code;

×

UNCOV

1669

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

1670

  int32_t lino = 0;

×

UNCOV

1672

  TSDB_CHECK_CONDITION((pReader != NULL) && (pReader->info.pSchema == NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1674

  code = metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, -1, &pReader->info.pSchema);

×

UNCOV

1675

  if (code != TSDB_CODE_SUCCESS || pReader->info.pSchema == NULL) {

×

1676

    terrno = code;

×

1677

    tsdbError("failed to get table schema, uid:%" PRIu64 ", it may have been dropped, ver:-1, %s", uid, pReader->idStr);

×

UNCOV

1679

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1680

  TSDB_CHECK_NULL(pReader->info.pSchema, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);

×

UNCOV

1682

  code = tsdbRowMergerInit(&pReader->status.merger, pReader->info.pSchema);

×

UNCOV

1683

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1685

_end:

×

UNCOV

1686

  if (code != TSDB_CODE_SUCCESS) {

×

1687

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

1688

    terrno = code;

×

1689

    return NULL;

×

UNCOV

1691

  return pReader->info.pSchema;

×

UNCOV

1694

static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockIter, SBlockData* pBlockData,

×

UNCOV

1696

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

1697

  int32_t             lino = 0;

×

UNCOV

1698

  STSchema*           pSchema = NULL;

×

UNCOV

1699

  SFileDataBlockInfo* pBlockInfo = NULL;

×

UNCOV

1700

  SBlockLoadSuppInfo* pSup = NULL;

×

UNCOV

1701

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

1702

  int64_t             st = 0;

×

UNCOV

1704

  SBrinRecord*        pRecord = NULL;

×

UNCOV

1706

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1707

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1709

  pSchema = pReader->info.pSchema;

×

UNCOV

1710

  st = taosGetTimestampUs();

×

UNCOV

1711

  pSup = &pReader->suppInfo;

×

UNCOV

1713

  tBlockDataReset(pBlockData);

×

UNCOV

1715

  if (pReader->info.pSchema == NULL) {

×

1716

    pSchema = getTableSchemaImpl(pReader, uid);

×

1717

    if (pSchema == NULL) {

×

1718

      tsdbError("%p table uid:%" PRIu64 " failed to get tableschema, code:%s, %s", pReader, uid, tstrerror(code),

×

1720

      TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

1724

  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

1725

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1727

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

1729

  blockInfoToRecord(&tmp, pBlockInfo, pSup);

×

UNCOV

1730

  pRecord = &tmp;

×

UNCOV

1731

  code = tsdbDataFileReadBlockDataByColumn(pReader->pFileReader, pRecord, pBlockData, pSchema, &pSup->colId[1],

×

UNCOV

1732

                                           pSup->numOfCols - 1);

×

UNCOV

1733

  if (code != TSDB_CODE_SUCCESS) {

×

1734

    tsdbError("%p error occurs in loading file block, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64

×

1738

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1741

  double elapsedTime = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

1743

  tsdbDebug("%p load file block into buffer, global index:%d, index in table block list:%d, brange:%" PRId64 "-%" PRId64

×

UNCOV

1748

  pReader->cost.blockLoadTime += elapsedTime;

×

UNCOV

1749

  pDumpInfo->allDumped = false;

×

UNCOV

1751

_end:

×

UNCOV

1752

  if (code != TSDB_CODE_SUCCESS) {

×

1753

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1755

  return code;

×

UNCOV

1761

static int32_t dataBlockPartiallyRequired(STimeWindow* pWindow, SVersionRange* pVerRange, SFileDataBlockInfo* pBlock) {

×

UNCOV

1762

  return (pWindow->ekey < pBlock->lastKey && pWindow->ekey >= pBlock->firstKey) ||

×

UNCOV

1763

         (pWindow->skey > pBlock->firstKey && pWindow->skey <= pBlock->lastKey) ||

×

UNCOV

1764

         (pVerRange->minVer > pBlock->minVer && pVerRange->minVer <= pBlock->maxVer) ||

×

UNCOV

1765

         (pVerRange->maxVer < pBlock->maxVer && pVerRange->maxVer >= pBlock->minVer);

×

UNCOV

1768

static int32_t getNeighborBlockOfTable(SDataBlockIter* pBlockIter, SFileDataBlockInfo* pBlockInfo,

×

UNCOV

1771

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

1772

  int32_t             lino = 0;

×

UNCOV

1773

  bool                asc = false;

×

UNCOV

1774

  int32_t             step = 0;

×

UNCOV

1775

  STableDataBlockIdx* pTableDataBlockIdx = NULL;

×

UNCOV

1776

  SFileDataBlockInfo* p = NULL;

×

UNCOV

1778

  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1779

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1780

  TSDB_CHECK_NULL(res, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1782

  *res = false;

×

UNCOV

1783

  asc = ASCENDING_TRAVERSE(order);

×

UNCOV

1784

  step = asc ? 1 : -1;

×

UNCOV

1786

  if (asc && pBlockInfo->tbBlockIdx >= taosArrayGetSize(pScanInfo->pBlockIdxList) - 1) {

×

UNCOV

1787

    *res = false;

×

UNCOV

1788

  } else if (!asc && pBlockInfo->tbBlockIdx == 0) {

×

UNCOV

1789

    *res = false;

×

UNCOV

1791

    TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1792

    TSDB_CHECK_NULL(nextIndex, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1793

    TSDB_CHECK_NULL(pRecord, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1794

    TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1796

    pTableDataBlockIdx = taosArrayGet(pScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx + step);

×

UNCOV

1797

    TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1799

    p = taosArrayGet(pBlockIter->blockList, pTableDataBlockIdx->globalIndex);

×

UNCOV

1800

    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1802

    blockInfoToRecord(pRecord, p, pSupInfo);

×

UNCOV

1804

    *nextIndex = pBlockInfo->tbBlockIdx + step;

×

UNCOV

1805

    *res = true;

×

UNCOV

1808

_end:

×

UNCOV

1809

  if (code != TSDB_CODE_SUCCESS) {

×

1810

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1812

  return code;

×

UNCOV

1815

static int32_t setFileBlockActiveInBlockIter(STsdbReader* pReader, SDataBlockIter* pBlockIter, int32_t index,

×

UNCOV

1817

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

1818

  int32_t              lino = 0;

×

UNCOV

1819

  const void*          p = NULL;

×

UNCOV

1821

  SFileDataBlockInfo*  pBlockInfo = NULL;

×

UNCOV

1822

  STableBlockScanInfo* pBlockScanInfo = NULL;

×

UNCOV

1823

  STableDataBlockIdx*  pTableDataBlockIdx = NULL;

×

UNCOV

1825

  TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1826

  TSDB_CHECK_CONDITION((index >= 0) && (index < pBlockIter->numOfBlocks), code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1828

  p = taosArrayGet(pBlockIter->blockList, index);

×

UNCOV

1829

  TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1831

  fblock = *(SFileDataBlockInfo*)p;

×

UNCOV

1832

  pBlockIter->index += step;

×

UNCOV

1834

  if (index != pBlockIter->index) {

×

1835

    if (index > pBlockIter->index) {

×

1836

      for (int32_t i = index - 1; i >= pBlockIter->index; --i) {

×

1837

        pBlockInfo = taosArrayGet(pBlockIter->blockList, i);

×

1838

        TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1840

        code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);

×

1841

        TSDB_CHECK_CODE(code, lino, _end);

×

1843

        pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx);

×

1844

        TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1846

        pTableDataBlockIdx->globalIndex = i + 1;

×

1848

        taosArraySet(pBlockIter->blockList, i + 1, pBlockInfo);

×

1850

    } else if (index < pBlockIter->index) {

×

1851

      for (int32_t i = index + 1; i <= pBlockIter->index; ++i) {

×

1852

        pBlockInfo = taosArrayGet(pBlockIter->blockList, i);

×

1853

        TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1855

        code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);

×

1856

        TSDB_CHECK_CODE(code, lino, _end);

×

1858

        pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx);

×

1859

        TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1861

        pTableDataBlockIdx->globalIndex = i - 1;

×

1862

        taosArraySet(pBlockIter->blockList, i - 1, pBlockInfo);

×

1866

    taosArraySet(pBlockIter->blockList, pBlockIter->index, &fblock);

×

1867

    pBlockScanInfo = NULL;

×

1868

    code = getTableBlockScanInfo(pReader->status.pTableMap, fblock.uid, &pBlockScanInfo, pReader->idStr);

×

1869

    TSDB_CHECK_CODE(code, lino, _end);

×

1871

    pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, fblock.tbBlockIdx);

×

1872

    TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

1874

    pTableDataBlockIdx->globalIndex = pBlockIter->index;

×

UNCOV

1877

_end:

×

UNCOV

1878

  if (code != TSDB_CODE_SUCCESS) {

×

1879

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1881

  return code;

×

UNCOV

1885

static bool overlapWithNeighborBlock2(SFileDataBlockInfo* pBlock, SBrinRecord* pRec, int32_t order, int32_t pkType,

×

UNCOV

1888

  if (ASCENDING_TRAVERSE(order)) {

×

UNCOV

1889

    if (pBlock->lastKey == pRec->firstKey.key.ts) {

×

UNCOV

1890

      if (numOfPk > 0) {

×

1891

        SValue v1 = {.type = pkType};

×

1892

        if (IS_VAR_DATA_TYPE(pkType)) {

×

1893

          v1.pData = (uint8_t*)varDataVal(pBlock->lastPk.pData), v1.nData = varDataLen(pBlock->lastPk.pData);

×

1895

          v1.val = pBlock->lastPk.val;

×

1897

        return (tValueCompare(&v1, &pRec->firstKey.key.pks[0]) == 0);

×

UNCOV

1899

        return true;

×

UNCOV

1902

      return false;

×

UNCOV

1905

    if (pBlock->firstKey == pRec->lastKey.key.ts) {

×

1906

      if (numOfPk > 0) {

×

1907

        SValue v1 = {.type = pkType};

×

1908

        if (IS_VAR_DATA_TYPE(pkType)) {

×

1909

          v1.pData = (uint8_t*)varDataVal(pBlock->firstPk.pData), v1.nData = varDataLen(pBlock->firstPk.pData);

×

1911

          v1.val = pBlock->firstPk.val;

×

1913

        return (tValueCompare(&v1, &pRec->lastKey.key.pks[0]) == 0);

×

1915

        return true;

×

UNCOV

1918

      return false;

×

UNCOV

1923

static int64_t getBoarderKeyInFiles(SFileDataBlockInfo* pBlock, STableBlockScanInfo* pScanInfo, int32_t order) {

×

UNCOV

1924

  bool ascScan = ASCENDING_TRAVERSE(order);

×

UNCOV

1926

  int64_t key = 0;

×

UNCOV

1927

  if (pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA) {

×

UNCOV

1928

    int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

1929

    key = ascScan ? TMIN(pBlock->firstKey, keyInStt) : TMAX(pBlock->lastKey, keyInStt);

×

UNCOV

1931

    key = ascScan ? pBlock->firstKey : pBlock->lastKey;

×

UNCOV

1934

  return key;

×

UNCOV

1937

static bool bufferDataInFileBlockGap(TSDBKEY keyInBuf, SFileDataBlockInfo* pBlock, STableBlockScanInfo* pScanInfo,

×

UNCOV

1939

  bool    ascScan = ASCENDING_TRAVERSE(order);

×

UNCOV

1940

  int64_t key = getBoarderKeyInFiles(pBlock, pScanInfo, order);

×

UNCOV

1942

  return (ascScan && (keyInBuf.ts != TSKEY_INITIAL_VAL && keyInBuf.ts < key)) ||

×

UNCOV

1943

         (!ascScan && (keyInBuf.ts != TSKEY_INITIAL_VAL && keyInBuf.ts > key));

×

UNCOV

1946

static bool keyOverlapFileBlock(TSDBKEY key, SFileDataBlockInfo* pBlock, SVersionRange* pVerRange) {

×

UNCOV

1947

  return (key.ts >= pBlock->firstKey && key.ts <= pBlock->lastKey) && (pBlock->maxVer >= pVerRange->minVer) &&

×

UNCOV

1948

         (pBlock->minVer <= pVerRange->maxVer);

×

UNCOV

1951

static int32_t getBlockToLoadInfo(SDataBlockToLoadInfo* pInfo, SFileDataBlockInfo* pBlockInfo,

×

UNCOV

1953

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

1954

  int32_t             lino = 0;

×

UNCOV

1955

  SBrinRecord         rec = {0};

×

UNCOV

1956

  int32_t             neighborIndex = 0;

×

UNCOV

1957

  int32_t             order = 0;

×

UNCOV

1958

  SBlockLoadSuppInfo* pSupInfo = NULL;

×

UNCOV

1960

  bool                hasNeighbor = false;

×

UNCOV

1962

  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1963

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

1965

  order = pReader->info.order;

×

UNCOV

1966

  pSupInfo = &pReader->suppInfo;

×

UNCOV

1968

  code = getNeighborBlockOfTable(&pReader->status.blockIter, pBlockInfo, pScanInfo, &neighborIndex, order, &rec,

×

UNCOV

1970

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

1973

  if (hasNeighbor) {

×

UNCOV

1974

    pInfo->overlapWithNeighborBlock =

×

UNCOV

1975

        overlapWithNeighborBlock2(pBlockInfo, &rec, order, pSupInfo->pk.type, pSupInfo->numOfPks);

×

UNCOV

1978

  blockInfoToRecord(&pRecord, pBlockInfo, pSupInfo);

×

UNCOV

1981

  pInfo->hasDupTs = (pBlockInfo->numRow > pBlockInfo->count) || (pBlockInfo->count <= 0);

×

UNCOV

1982

  pInfo->overlapWithDelInfo = overlapWithDelSkyline(pScanInfo, &pRecord, order);

×

UNCOV

1985

  if (pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA) {

×

UNCOV

1986

    int64_t nextProcKeyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

1987

    pInfo->overlapWithSttBlock = !(pBlockInfo->lastKey < nextProcKeyInStt || pBlockInfo->firstKey > nextProcKeyInStt);

×

UNCOV

1990

  pInfo->moreThanCapcity = pBlockInfo->numRow > pReader->resBlockInfo.capacity;

×

UNCOV

1991

  pInfo->partiallyRequired = dataBlockPartiallyRequired(&pReader->info.window, &pReader->info.verRange, pBlockInfo);

×

UNCOV

1992

  pInfo->overlapWithKeyInBuf = keyOverlapFileBlock(keyInBuf, pBlockInfo, &pReader->info.verRange);

×

UNCOV

1994

_end:

×

UNCOV

1995

  if (code != TSDB_CODE_SUCCESS) {

×

1996

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

1998

  return code;

×

UNCOV

2007

static int32_t fileBlockShouldLoad(STsdbReader* pReader, SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pScanInfo,

×

UNCOV

2009

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

2010

  int32_t              lino = 0;

×

UNCOV

2011

  SDataBlockToLoadInfo info = {0};

×

UNCOV

2013

  TSDB_CHECK_NULL(load, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2015

  *load = false;

×

UNCOV

2016

  code = getBlockToLoadInfo(&info, pBlockInfo, pScanInfo, keyInBuf, pReader);

×

UNCOV

2017

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2019

  *load = (info.overlapWithNeighborBlock || info.hasDupTs || info.partiallyRequired || info.overlapWithKeyInBuf ||

×

UNCOV

2020

           info.moreThanCapcity || info.overlapWithDelInfo || info.overlapWithSttBlock);

×

UNCOV

2023

  if (*load) {

×

UNCOV

2024

    tsdbDebug("%p uid:%" PRIu64

×

UNCOV

2032

_end:

×

UNCOV

2033

  if (code != TSDB_CODE_SUCCESS) {

×

2034

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2036

  return code;

×

UNCOV

2039

static int32_t isCleanFileDataBlock(STsdbReader* pReader, SFileDataBlockInfo* pBlockInfo,

×

UNCOV

2041

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

2042

  int32_t              lino = 0;

×

UNCOV

2043

  SDataBlockToLoadInfo info = {0};

×

UNCOV

2045

  TSDB_CHECK_NULL(res, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2047

  *res = false;

×

UNCOV

2048

  code = getBlockToLoadInfo(&info, pBlockInfo, pScanInfo, keyInBuf, pReader);

×

UNCOV

2049

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2051

  *res = !(info.overlapWithNeighborBlock || info.hasDupTs || info.overlapWithKeyInBuf || info.overlapWithDelInfo ||

×

UNCOV

2052

           info.overlapWithSttBlock);

×

UNCOV

2054

_end:

×

UNCOV

2055

  if (code != TSDB_CODE_SUCCESS) {

×

2056

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2058

  return code;

×

UNCOV

2061

static int32_t initRowMergeIfNeeded(STsdbReader* pReader, int64_t uid) {

×

UNCOV

2062

  int32_t     code = TSDB_CODE_SUCCESS;

×

UNCOV

2063

  int32_t     lino = 0;

×

UNCOV

2064

  SRowMerger* pMerger = NULL;

×

UNCOV

2065

  STSchema*   ps = NULL;

×

UNCOV

2067

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2069

  pMerger = &pReader->status.merger;

×

UNCOV

2071

  if (pMerger->pArray == NULL) {

×

UNCOV

2072

    ps = getTableSchemaImpl(pReader, uid);

×

UNCOV

2073

    TSDB_CHECK_NULL(ps, code, lino, _end, terrno);

×

UNCOV

2076

_end:

×

UNCOV

2077

  if (code != TSDB_CODE_SUCCESS) {

×

2078

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2080

  return code;

×

UNCOV

2083

static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, int64_t endKey) {

×

UNCOV

2084

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

2085

  int32_t      lino = 0;

×

UNCOV

2086

  int64_t      st = 0;

×

UNCOV

2087

  SSDataBlock* pBlock = NULL;

×

UNCOV

2089

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2091

  if (!(pBlockScanInfo->iiter.hasVal || pBlockScanInfo->iter.hasVal)) {

×

UNCOV

2092

    goto _end;

×

UNCOV

2095

  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);

×

UNCOV

2096

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2098

  st = taosGetTimestampUs();

×

UNCOV

2099

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

2100

  code = buildDataBlockFromBufImpl(pBlockScanInfo, endKey, pReader->resBlockInfo.capacity, pReader);

×

UNCOV

2101

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2103

  double el = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

2104

  updateComposedBlockInfo(pReader, el, pBlockScanInfo);

×

UNCOV

2106

  tsdbDebug("%p build data block from cache completed, elapsed time:%.2f ms, numOfRows:%" PRId64 ", brange:%" PRId64

×

UNCOV

2111

  pReader->cost.buildmemBlock += el;

×

UNCOV

2113

_end:

×

UNCOV

2114

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

2115

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2117

  return code;

×

UNCOV

2120

static int32_t tryCopyDistinctRowFromFileBlock(STsdbReader* pReader, SBlockData* pBlockData, SRowKey* pKey,

×

UNCOV

2125

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

2126

  int32_t lino = 0;

×

UNCOV

2127

  bool    asc = false;

×

UNCOV

2129

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2130

  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2131

  TSDB_CHECK_NULL(copied, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2133

  *copied = false;

×

UNCOV

2134

  asc = (pReader->info.order == TSDB_ORDER_ASC);

×

UNCOV

2135

  if ((pDumpInfo->rowIndex < pDumpInfo->totalRows - 1 && asc) || (pDumpInfo->rowIndex > 0 && (!asc))) {

×

UNCOV

2136

    int32_t step = ASCENDING_TRAVERSE(pReader->info.order) ? 1 : -1;

×

UNCOV

2139

    TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2140

    tColRowGetKey(pBlockData, pDumpInfo->rowIndex + step, &nextRowKey);

×

UNCOV

2142

    if (pkCompEx(pKey, &nextRowKey) != 0) {  // merge is not needed

×

UNCOV

2143

      code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, pBlockData, pDumpInfo->rowIndex);

×

UNCOV

2144

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2145

      pDumpInfo->rowIndex += step;

×

UNCOV

2146

      *copied = true;

×

UNCOV

2150

_end:

×

UNCOV

2151

  if (code != TSDB_CODE_SUCCESS) {

×

2152

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2154

  return code;

×

UNCOV

2157

static int32_t nextRowFromSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, int32_t pkSrcSlot,

×

UNCOV

2159

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

2160

  int32_t  lino = 0;

×

UNCOV

2161

  int32_t  order = 0;

×

UNCOV

2162

  int32_t  step = 0;

×

UNCOV

2163

  SRowKey* pNextProc = NULL;

×

UNCOV

2165

  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2166

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2168

  order = pSttBlockReader->order;

×

UNCOV

2169

  step = ASCENDING_TRAVERSE(order) ? 1 : -1;

×

UNCOV

2170

  pNextProc = &pScanInfo->sttKeyInfo.nextProcKey;

×

UNCOV

2172

  while (1) {

×

UNCOV

2173

    bool hasVal = false;

×

UNCOV

2174

    code = tMergeTreeNext(&pSttBlockReader->mergeTree, &hasVal);

×

UNCOV

2175

    if (code) {

×

2176

      tsdbError("failed to iter the next row in stt-file merge tree, code:%s, %s", tstrerror(code),

×

UNCOV

2178

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2181

    if (!hasVal) {  // the next value will be the accessed key in stt

×

UNCOV

2182

      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;

×

UNCOV

2185

      pNextProc->ts += step;

×

UNCOV

2186

      if (pSttBlockReader->numOfPks > 0) {

×

UNCOV

2187

        if (IS_NUMERIC_TYPE(pNextProc->pks[0].type)) {

×

UNCOV

2188

          pNextProc->pks[0].val = INT64_MIN;

×

UNCOV

2190

          memset(pNextProc->pks[0].pData, 0, pNextProc->pks[0].nData);

×

UNCOV

2193

      goto _end;

×

UNCOV

2196

    TSDBROW* pRow = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

2197

    int64_t  key = pRow->pBlockData->aTSKEY[pRow->iRow];

×

UNCOV

2198

    int64_t  ver = pRow->pBlockData->aVersion[pRow->iRow];

×

UNCOV

2200

    if (pSttBlockReader->numOfPks == 0) {

×

UNCOV

2201

      pSttBlockReader->currentKey.ts = key;

×

UNCOV

2203

      tColRowGetKeyDeepCopy(pRow->pBlockData, pRow->iRow, pkSrcSlot, &pSttBlockReader->currentKey);

×

UNCOV

2206

    tColRowGetKeyDeepCopy(pRow->pBlockData, pRow->iRow, pkSrcSlot, pNextProc);

×

UNCOV

2208

    if (pScanInfo->delSkyline != NULL && TARRAY_SIZE(pScanInfo->delSkyline) > 0) {

×

UNCOV

2209

      bool dropped = false;

×

UNCOV

2210

      code = hasBeenDropped(pScanInfo->delSkyline, &pScanInfo->sttBlockDelIndex, key, ver, order, pVerRange,

×

UNCOV

2211

                            pSttBlockReader->numOfPks > 0, &dropped);

×

UNCOV

2212

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2213

      if (!dropped) {

×

UNCOV

2214

        pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;

×

UNCOV

2215

        goto _end;

×

UNCOV

2218

      pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;

×

UNCOV

2219

      goto _end;

×

UNCOV

2223

_end:

×

UNCOV

2224

  if (code != TSDB_CODE_SUCCESS) {

×

2225

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2227

  return code;

×

UNCOV

2230

static void doPinSttBlock(SSttBlockReader* pSttBlockReader) { tMergeTreePinSttBlock(&pSttBlockReader->mergeTree); }

×

UNCOV

2232

static void doUnpinSttBlock(SSttBlockReader* pSttBlockReader) { tMergeTreeUnpinSttBlock(&pSttBlockReader->mergeTree); }

×

UNCOV

2234

static int32_t tryCopyDistinctRowFromSttBlock(TSDBROW* fRow, SSttBlockReader* pSttBlockReader,

×

UNCOV

2237

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

2238

  int32_t  lino = 0;

×

UNCOV

2239

  SRowKey* pNext = NULL;

×

UNCOV

2241

  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2242

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2243

  TSDB_CHECK_NULL(copied, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2245

  *copied = false;

×

UNCOV

2248

  doPinSttBlock(pSttBlockReader);

×

UNCOV

2249

  code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);

×

UNCOV

2250

  doUnpinSttBlock(pSttBlockReader);

×

UNCOV

2251

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2253

  if (hasDataInSttBlock(pScanInfo)) {

×

UNCOV

2254

    pNext = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

2255

    if (pkCompEx(pSttKey, pNext) != 0) {

×

UNCOV

2256

      code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, fRow->pBlockData, fRow->iRow);

×

UNCOV

2257

      *copied = (code == TSDB_CODE_SUCCESS);

×

UNCOV

2258

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2261

    code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, fRow->pBlockData, fRow->iRow);

×

UNCOV

2262

    *copied = (code == TSDB_CODE_SUCCESS);

×

UNCOV

2263

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2266

_end:

×

UNCOV

2267

  if (code != TSDB_CODE_SUCCESS) {

×

2268

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2270

  return code;

×

UNCOV

2274

  int32_t   code = TSDB_CODE_SUCCESS;

×

UNCOV

2275

  int32_t   lino = 0;

×

UNCOV

2276

  STSchema* ps = NULL;

×

UNCOV

2277

  void**    p = NULL;

×

UNCOV

2279

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2282

  if (pReader->info.pSchema == NULL) {

×

2283

    ps = getTableSchemaImpl(pReader, uid);

×

2284

    TSDB_CHECK_NULL(ps, code, lino, _end, terrno);

×

UNCOV

2287

  if (pReader->info.pSchema && sversion == pReader->info.pSchema->version) {

×

UNCOV

2288

    ps = pReader->info.pSchema;

×

UNCOV

2289

    goto _end;

×

UNCOV

2292

  p = tSimpleHashGet(pReader->pSchemaMap, &sversion, sizeof(sversion));

×

UNCOV

2293

  if (p != NULL) {

×

UNCOV

2294

    ps = *(STSchema**)p;

×

UNCOV

2295

    goto _end;

×

UNCOV

2298

  code = metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, sversion, &ps);

×

UNCOV

2299

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2301

  code = tSimpleHashPut(pReader->pSchemaMap, &sversion, sizeof(sversion), &ps, POINTER_BYTES);

×

UNCOV

2302

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2304

_end:

×

UNCOV

2305

  if (code != TSDB_CODE_SUCCESS) {

×

2306

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

2307

    terrno = code;

×

2308

    return NULL;

×

UNCOV

2310

  return ps;

×

UNCOV

2313

static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, TSDBROW* pRow,

×

UNCOV

2315

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

2316

  int32_t             lino = 0;

×

UNCOV

2317

  SRowMerger*         pMerger = NULL;

×

UNCOV

2318

  SRow*               pTSRow = NULL;

×

UNCOV

2319

  SBlockData*         pBlockData = NULL;

×

UNCOV

2320

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

2321

  SRowKey*            pSttKey = NULL;

×

UNCOV

2322

  int32_t             pkSrcSlot = 0;

×

UNCOV

2323

  SRowKey             k = {0};

×

UNCOV

2324

  STSchema*           pSchema = NULL;

×

UNCOV

2326

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2327

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2328

  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2330

  pMerger = &pReader->status.merger;

×

UNCOV

2331

  pBlockData = &pReader->status.fileBlockData;

×

UNCOV

2332

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

2333

  pkSrcSlot = pReader->suppInfo.pkSrcSlot;

×

UNCOV

2335

  if (hasDataInSttBlock(pBlockScanInfo) && (!pBlockScanInfo->cleanSttBlocks)) {

×

UNCOV

2336

    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

2339

  tRowGetKeyEx(pRow, &k);

×

UNCOV

2341

  if (pRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

2342

    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);

×

UNCOV

2343

    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

2346

  SRowKey* pfKey = &(SRowKey){0};

×

UNCOV

2347

  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {

×

UNCOV

2348

    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pfKey);

×

UNCOV

2350

    pfKey = NULL;

×

UNCOV

2353

  TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);

×

UNCOV

2356

  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);

×

UNCOV

2357

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2359

  SRowKey minKey = k;

×

UNCOV

2360

  if (pReader->info.order == TSDB_ORDER_ASC) {

×

UNCOV

2361

    if (pfKey != NULL && pkCompEx(pfKey, &minKey) < 0) {

×

UNCOV

2362

      minKey = *pfKey;

×

UNCOV

2365

    if (pSttKey != NULL && pkCompEx(pSttKey, &minKey) < 0) {

×

UNCOV

2366

      minKey = *pSttKey;

×

UNCOV

2369

    if (pfKey != NULL && pkCompEx(pfKey, &minKey) > 0) {

×

UNCOV

2370

      minKey = *pfKey;

×

UNCOV

2373

    if (pSttKey != NULL && pkCompEx(pSttKey, &minKey) > 0) {

×

UNCOV

2374

      minKey = *pSttKey;

×

UNCOV

2380

  tRowKeyAssign(&pBlockScanInfo->lastProcKey, &minKey);

×

UNCOV

2383

  if (pkCompEx(&minKey, pfKey) == 0) {

×

UNCOV

2384

    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

2385

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2387

    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pfKey, pReader);

×

UNCOV

2388

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2391

  if (pkCompEx(&minKey, pSttKey) == 0) {

×

UNCOV

2392

    TSDBROW* fRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

2393

    code = tsdbRowMergerAdd(pMerger, fRow1, NULL);

×

UNCOV

2394

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2395

    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,

×

UNCOV

2396

                                 pReader->idStr);

×

UNCOV

2397

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2400

  if (pkCompEx(&minKey, &k) == 0) {

×

UNCOV

2401

    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);

×

UNCOV

2402

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2404

    code = doMergeRowsInBuf(pIter, pBlockScanInfo->uid, &k, pBlockScanInfo->delSkyline, pReader);

×

UNCOV

2405

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2408

  code = tsdbRowMergerGetRow(pMerger, &pTSRow);

×

UNCOV

2409

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2411

  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);

×

UNCOV

2413

  taosMemoryFreeClear(pTSRow);

×

UNCOV

2414

  tsdbRowMergerClear(pMerger);

×

UNCOV

2415

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2417

_end:

×

UNCOV

2418

  if (code != TSDB_CODE_SUCCESS) {

×

2419

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2421

  return code;

×

UNCOV

2424

static int32_t mergeFileBlockAndSttBlock(STsdbReader* pReader, SSttBlockReader* pSttBlockReader, SRowKey* pKey,

×

UNCOV

2426

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

2427

  int32_t             lino = 0;

×

UNCOV

2428

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

2429

  SRowMerger*         pMerger = NULL;

×

UNCOV

2430

  SRow*               pTSRow = NULL;

×

UNCOV

2431

  int32_t             pkSrcSlot = 0;

×

UNCOV

2433

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2434

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2435

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2437

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

2438

  pMerger = &pReader->status.merger;

×

UNCOV

2439

  pkSrcSlot = pReader->suppInfo.pkSrcSlot;

×

UNCOV

2442

  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);

×

UNCOV

2443

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2445

  bool dataInDataFile = hasDataInFileBlock(pBlockData, pDumpInfo);

×

UNCOV

2446

  bool dataInSttFile = hasDataInSttBlock(pBlockScanInfo);

×

UNCOV

2448

  if (dataInDataFile && (!dataInSttFile)) {

×

UNCOV

2450

    code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

UNCOV

2451

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2452

  } else if ((!dataInDataFile) && dataInSttFile) {

×

UNCOV

2454

    code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);

×

UNCOV

2455

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2456

  } else if (pBlockScanInfo->cleanSttBlocks && pReader->info.execMode == READER_EXEC_ROWS) {

×

2458

    code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

2459

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2461

    TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2463

    TSDBROW  fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);

×

UNCOV

2464

    SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

2466

    int32_t ret = pkCompEx(pKey, pSttKey);

×

UNCOV

2468

    if (ASCENDING_TRAVERSE(pReader->info.order)) {

×

UNCOV

2469

      if (ret < 0) {  // asc

×

UNCOV

2470

        code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

UNCOV

2471

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2472

      } else if (ret > 0) {

×

UNCOV

2473

        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);

×

UNCOV

2474

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2477

      if (ret > 0) {

×

UNCOV

2478

        code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

UNCOV

2479

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2480

      } else if (ret < 0) {

×

UNCOV

2481

        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);

×

UNCOV

2482

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2485

    if (ret != 0) {

×

UNCOV

2486

      goto _end;

×

UNCOV

2490

    tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);

×

UNCOV

2495

    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

2496

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2498

    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

UNCOV

2499

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2501

    TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

2502

    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);

×

UNCOV

2503

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2506

    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,

×

UNCOV

2507

                                 pReader->idStr);

×

UNCOV

2508

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2510

    code = tsdbRowMergerGetRow(pMerger, &pTSRow);

×

UNCOV

2511

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2513

    code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);

×

UNCOV

2515

    taosMemoryFreeClear(pTSRow);

×

UNCOV

2516

    tsdbRowMergerClear(pMerger);

×

UNCOV

2517

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2520

_end:

×

UNCOV

2521

  if (code != TSDB_CODE_SUCCESS) {

×

2522

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2524

  return code;

×

UNCOV

2527

static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, SBlockData* pBlockData,

×

UNCOV

2529

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

2530

  int32_t             lino = 0;

×

UNCOV

2531

  SRowMerger*         pMerger = NULL;

×

UNCOV

2532

  SRow*               pTSRow = NULL;

×

UNCOV

2533

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

2534

  SArray*             pDelList = NULL;

×

UNCOV

2535

  int32_t             pkSrcSlot = 0;

×

UNCOV

2536

  TSDBROW*            pRow = NULL;

×

UNCOV

2537

  TSDBROW*            piRow = NULL;

×

UNCOV

2538

  SRowKey*            pSttKey = NULL;

×

UNCOV

2540

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2541

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2542

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2544

  pMerger = &pReader->status.merger;

×

UNCOV

2545

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

2546

  pDelList = pBlockScanInfo->delSkyline;

×

UNCOV

2547

  pkSrcSlot = pReader->suppInfo.pkSrcSlot;

×

UNCOV

2549

  code = getValidMemRow(&pBlockScanInfo->iter, pDelList, pReader, &pRow);

×

UNCOV

2550

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2551

  code = getValidMemRow(&pBlockScanInfo->iiter, pDelList, pReader, &piRow);

×

UNCOV

2552

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2554

  if (hasDataInSttBlock(pBlockScanInfo) && (!pBlockScanInfo->cleanSttBlocks)) {

×

UNCOV

2555

    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

2558

  SRowKey* pfKey = &(SRowKey){0};

×

UNCOV

2559

  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {

×

UNCOV

2560

    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pfKey);

×

UNCOV

2562

    pfKey = NULL;

×

UNCOV

2565

  SRowKey k = {0}, ik = {0};

×

UNCOV

2566

  tRowGetKeyEx(pRow, &k);

×

UNCOV

2567

  tRowGetKeyEx(piRow, &ik);

×

UNCOV

2569

  STSchema* pSchema = NULL;

×

UNCOV

2570

  if (pRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

2571

    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);

×

UNCOV

2572

    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

2575

  STSchema* piSchema = NULL;

×

UNCOV

2576

  if (piRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

2577

    piSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(piRow), pReader, pBlockScanInfo->uid);

×

UNCOV

2578

    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

2582

  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);

×

UNCOV

2583

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2585

  SRowKey minKey = k;

×

UNCOV

2586

  if (ASCENDING_TRAVERSE(pReader->info.order)) {

×

UNCOV

2587

    if (pkCompEx(&ik, &minKey) < 0) {  // minKey > ik.key.ts) {

×

UNCOV

2588

      minKey = ik;

×

UNCOV

2591

    if ((pfKey != NULL) && (pkCompEx(pfKey, &minKey) < 0)) {

×

UNCOV

2592

      minKey = *pfKey;

×

UNCOV

2595

    if ((pSttKey != NULL) && (pkCompEx(pSttKey, &minKey) < 0)) {

×

UNCOV

2596

      minKey = *pSttKey;

×

UNCOV

2599

    if (pkCompEx(&ik, &minKey) > 0) {

×

2600

      minKey = ik;

×

UNCOV

2603

    if ((pfKey != NULL) && (pkCompEx(pfKey, &minKey) > 0)) {

×

2604

      minKey = *pfKey;

×

UNCOV

2607

    if ((pSttKey != NULL) && (pkCompEx(pSttKey, &minKey) > 0)) {

×

2608

      minKey = *pSttKey;

×

UNCOV

2612

  tRowKeyAssign(&pBlockScanInfo->lastProcKey, &minKey);

×

UNCOV

2615

  if (pkCompEx(&minKey, pfKey) == 0) {

×

UNCOV

2616

    TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);

×

UNCOV

2617

    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

2618

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2620

    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pfKey, pReader);

×

UNCOV

2621

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2624

  if (pkCompEx(&minKey, pSttKey) == 0) {

×

UNCOV

2625

    TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

2626

    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);

×

UNCOV

2627

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2629

    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,

×

UNCOV

2630

                                 pReader->idStr);

×

UNCOV

2631

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2634

  if (pkCompEx(&minKey, &ik) == 0) {

×

UNCOV

2635

    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);

×

UNCOV

2636

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2638

    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, &ik, pBlockScanInfo->delSkyline, pReader);

×

UNCOV

2639

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2642

  if (pkCompEx(&minKey, &k) == 0) {

×

UNCOV

2643

    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);

×

UNCOV

2644

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2646

    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, &k, pBlockScanInfo->delSkyline, pReader);

×

UNCOV

2647

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2650

  code = tsdbRowMergerGetRow(pMerger, &pTSRow);

×

UNCOV

2651

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2653

  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);

×

UNCOV

2655

  taosMemoryFreeClear(pTSRow);

×

UNCOV

2656

  tsdbRowMergerClear(pMerger);

×

UNCOV

2657

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2659

_end:

×

UNCOV

2660

  if (code != TSDB_CODE_SUCCESS) {

×

2661

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2663

  return code;

×

UNCOV

2666

int32_t doInitMemDataIter(STsdbReader* pReader, STbData** pData, STableBlockScanInfo* pBlockScanInfo, STsdbRowKey* pKey,

×

UNCOV

2668

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

2669

  int32_t lino = 0;

×

UNCOV

2670

  int32_t backward = false;

×

UNCOV

2672

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2673

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2674

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2675

  TSDB_CHECK_NULL(type, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2677

  backward = (!ASCENDING_TRAVERSE(pReader->info.order));

×

UNCOV

2678

  pIter->hasVal = false;

×

UNCOV

2680

  if (pMem != NULL) {

×

UNCOV

2681

    TSDB_CHECK_NULL(pData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2682

    *pData = tsdbGetTbDataFromMemTable(pMem, pReader->info.suid, pBlockScanInfo->uid);

×

UNCOV

2684

    if ((*pData) != NULL) {

×

UNCOV

2685

      code = tsdbTbDataIterCreate((*pData), pKey, backward, &pIter->iter);

×

UNCOV

2686

      if (code == TSDB_CODE_SUCCESS) {

×

UNCOV

2687

        pIter->hasVal = (tsdbTbDataIterGet(pIter->iter) != NULL);

×

UNCOV

2689

        tsdbDebug("%p uid:%" PRIu64 ", check data in %s from skey:%" PRId64 ", order:%d, ts range in buf:%" PRId64

×

2694

        tsdbError("%p uid:%" PRIu64 ", failed to create iterator for %s, code:%s, %s", pReader, pBlockScanInfo->uid,

×

2696

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2700

    tsdbDebug("%p uid:%" PRIu64 ", no data in %s, %s", pReader, pBlockScanInfo->uid, type, pReader->idStr);

×

UNCOV

2703

_end:

×

UNCOV

2704

  if (code != TSDB_CODE_SUCCESS) {

×

2705

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2707

  return code;

×

UNCOV

2710

static int32_t doForwardDataIter(SRowKey* pKey, SIterInfo* pIter, STableBlockScanInfo* pBlockScanInfo,

×

UNCOV

2712

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

2713

  int32_t  lino = 0;

×

UNCOV

2714

  SRowKey  rowKey = {0};

×

UNCOV

2715

  TSDBROW* pRow = NULL;

×

UNCOV

2717

  while (1) {

×

UNCOV

2718

    code = getValidMemRow(pIter, pBlockScanInfo->delSkyline, pReader, &pRow);

×

UNCOV

2719

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2720

    if (!pIter->hasVal) {

×

UNCOV

2721

      break;

×

UNCOV

2724

    tRowGetKeyEx(pRow, &rowKey);

×

UNCOV

2725

    int32_t ret = pkCompEx(pKey, &rowKey);

×

UNCOV

2726

    if (ret == 0) {

×

2727

      pIter->hasVal = tsdbTbDataIterNext(pIter->iter);

×

UNCOV

2729

      break;

×

UNCOV

2733

_end:

×

UNCOV

2734

  if (code != TSDB_CODE_SUCCESS) {

×

2735

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2737

  return code;

×

UNCOV

2741

static int32_t forwardDataIter(SRowKey* pKey, STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {

×

UNCOV

2742

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

2743

  int32_t lino = 0;

×

UNCOV

2745

  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2746

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2748

  code = doForwardDataIter(pKey, &pBlockScanInfo->iter, pBlockScanInfo, pReader);

×

UNCOV

2749

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2750

  code = doForwardDataIter(pKey, &pBlockScanInfo->iiter, pBlockScanInfo, pReader);

×

UNCOV

2751

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2753

_end:

×

UNCOV

2754

  if (code != TSDB_CODE_SUCCESS) {

×

2755

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2757

  return code;

×

UNCOV

2760

static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {

×

UNCOV

2761

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

2762

  int32_t        lino = 0;

×

UNCOV

2763

  STbData*       d = NULL;

×

UNCOV

2764

  STbData*       di = NULL;

×

UNCOV

2765

  bool           asc = false;

×

UNCOV

2766

  bool           forward = true;

×

UNCOV

2767

  STsdbReadSnap* pSnap = NULL;

×

UNCOV

2768

  STimeWindow*   pWindow = NULL;

×

UNCOV

2771

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2772

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2774

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

2775

  pSnap = pReader->pReadSnap;

×

UNCOV

2776

  pWindow = &pReader->info.window;

×

UNCOV

2778

  if (pBlockScanInfo->iterInit) {

×

UNCOV

2779

    goto _end;

×

UNCOV

2782

  startKey.key = pBlockScanInfo->lastProcKey;

×

UNCOV

2783

  startKey.version = asc ? pReader->info.verRange.minVer : pReader->info.verRange.maxVer;

×

UNCOV

2784

  if ((asc && (startKey.key.ts < pWindow->skey)) || ((!asc) && startKey.key.ts > pWindow->ekey)) {

×

UNCOV

2785

    startKey.key.ts = asc ? pWindow->skey : pWindow->ekey;

×

UNCOV

2786

    forward = false;

×

UNCOV

2789

  code = doInitMemDataIter(pReader, &d, pBlockScanInfo, &startKey, pSnap->pMem, &pBlockScanInfo->iter, "mem");

×

UNCOV

2790

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2792

  code = doInitMemDataIter(pReader, &di, pBlockScanInfo, &startKey, pSnap->pIMem, &pBlockScanInfo->iiter, "imem");

×

UNCOV

2793

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2795

  code = loadMemTombData(&pBlockScanInfo->pMemDelData, d, di, pReader->info.verRange.maxVer);

×

UNCOV

2796

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2798

  if (forward) {

×

UNCOV

2799

    code = forwardDataIter(&startKey.key, pBlockScanInfo, pReader);

×

UNCOV

2800

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2803

  pBlockScanInfo->iterInit = true;

×

UNCOV

2805

_end:

×

UNCOV

2806

  if (code != TSDB_CODE_SUCCESS) {

×

2807

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2809

  return code;

×

UNCOV

2812

static int32_t isValidFileBlockRow(SBlockData* pBlockData, int32_t rowIndex, STableBlockScanInfo* pBlockScanInfo,

×

UNCOV

2814

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

2815

  int32_t lino = 0;

×

UNCOV

2817

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2818

  TSDB_CHECK_NULL(valid, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2820

  *valid = false;

×

UNCOV

2822

  if (pBlockData->aUid != NULL) {

×

2823

    uint64_t uid = pBlockData->aUid[rowIndex];

×

2824

    if (uid != pBlockScanInfo->uid) {  // move to next row

×

2825

      *valid = false;

×

2826

      goto _end;

×

UNCOV

2830

  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2832

  int64_t ver = pBlockData->aVersion[rowIndex];

×

UNCOV

2833

  if (ver > pInfo->verRange.maxVer || ver < pInfo->verRange.minVer) {

×

2834

    *valid = false;

×

2835

    goto _end;

×

UNCOV

2838

  int64_t ts = pBlockData->aTSKEY[rowIndex];

×

UNCOV

2839

  if (ts > pInfo->window.ekey || ts < pInfo->window.skey) {

×

UNCOV

2840

    *valid = false;

×

UNCOV

2841

    goto _end;

×

UNCOV

2844

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2845

  if ((asc && (ts < pBlockScanInfo->lastProcKey.ts)) || ((!asc) && (ts > pBlockScanInfo->lastProcKey.ts))) {

×

2846

    *valid = false;

×

2847

    goto _end;

×

UNCOV

2850

  if (ts == pBlockScanInfo->lastProcKey.ts) {  // todo opt perf

×

UNCOV

2852

    tColRowGetKey(pBlockData, rowIndex, &nextRowKey);

×

UNCOV

2853

    if (pkCompEx(&pBlockScanInfo->lastProcKey, &nextRowKey) == 0) {

×

2854

      *valid = false;

×

2855

      goto _end;

×

UNCOV

2859

  if (pBlockScanInfo->delSkyline != NULL && TARRAY_SIZE(pBlockScanInfo->delSkyline) > 0) {

×

UNCOV

2860

    bool dropped = false;

×

UNCOV

2861

    code = hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, ts, ver, pInfo->order,

×

UNCOV

2862

                          &pInfo->verRange, pReader->suppInfo.numOfPks > 0, &dropped);

×

UNCOV

2863

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2864

    if (dropped) {

×

UNCOV

2865

      *valid = false;

×

UNCOV

2866

      goto _end;

×

UNCOV

2870

  *valid = true;

×

UNCOV

2872

_end:

×

UNCOV

2873

  if (code != TSDB_CODE_SUCCESS) {

×

2874

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

2876

  return code;

×

UNCOV

2879

static void initSttBlockReader(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {

×

UNCOV

2880

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

2881

  int32_t              lino = 0;

×

UNCOV

2882

  int32_t              order = 0;

×

UNCOV

2883

  bool                 asc = false;

×

UNCOV

2884

  int64_t              st = 0;

×

UNCOV

2885

  SSttDataInfoForTable info = (SSttDataInfoForTable){0};

×

UNCOV

2887

  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2888

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2889

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

2891

  order = pReader->info.order;

×

UNCOV

2892

  asc = ASCENDING_TRAVERSE(order);

×

UNCOV

2895

  if (pSttBlockReader->uid == pScanInfo->uid) {

×

UNCOV

2896

    goto _end;

×

UNCOV

2899

  if (pSttBlockReader->uid != 0) {

×

UNCOV

2900

    tMergeTreeClose(&pSttBlockReader->mergeTree);

×

UNCOV

2903

  pSttBlockReader->uid = pScanInfo->uid;

×

UNCOV

2906

  if (pScanInfo->cleanSttBlocks && (pReader->info.execMode == READER_EXEC_ROWS)) {

×

UNCOV

2908

    if (pScanInfo->sttBlockReturned) {

×

2909

      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;

×

2910

      tsdbDebug("uid:%" PRIu64 " set no stt-file data after stt-block retrieved, %s", pScanInfo->uid, pReader->idStr);

×

UNCOV

2912

    goto _end;

×

UNCOV

2915

  STimeWindow w = pSttBlockReader->window;

×

UNCOV

2916

  if (asc) {

×

UNCOV

2917

    w.skey = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

2919

    w.ekey = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

2922

  st = taosGetTimestampUs();

×

UNCOV

2923

  tsdbDebug("init stt block reader, window:%" PRId64 "-%" PRId64 ", uid:%" PRIu64 ", %s", w.skey, w.ekey,

×

UNCOV

2926

  SMergeTreeConf conf = {

×

UNCOV

2927

      .uid = pScanInfo->uid,

×

UNCOV

2928

      .suid = pReader->info.suid,

×

UNCOV

2929

      .pTsdb = pReader->pTsdb,

×

UNCOV

2933

      .pSchema = pReader->info.pSchema,

×

UNCOV

2934

      .pCurrentFileset = pReader->status.pCurrentFileset,

×

UNCOV

2935

      .backward = (pSttBlockReader->order == TSDB_ORDER_DESC),

×

UNCOV

2936

      .pSttFileBlockIterArray = pReader->status.pLDataIterArray,

×

UNCOV

2937

      .pCols = pReader->suppInfo.colId,

×

UNCOV

2938

      .numOfCols = pReader->suppInfo.numOfCols,

×

UNCOV

2940

      .pCurRowKey = &pScanInfo->sttKeyInfo.nextProcKey,

×

UNCOV

2942

      .idstr = pReader->idStr,

×

UNCOV

2943

      .rspRows = (pReader->info.execMode == READER_EXEC_ROWS),

×

UNCOV

2946

  info.pKeyRangeList = taosArrayInit(4, sizeof(SSttKeyRange));

×

UNCOV

2947

  TSDB_CHECK_NULL(info.pKeyRangeList, code, lino, _end, terrno);

×

UNCOV

2949

  code = tMergeTreeOpen2(&pSttBlockReader->mergeTree, &conf, &info);

×

UNCOV

2950

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2952

  code = initMemDataIterator(pScanInfo, pReader);

×

UNCOV

2953

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2955

  code = initDelSkylineIterator(pScanInfo, pReader->info.order, &pReader->cost);

×

UNCOV

2956

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2958

  if (conf.rspRows) {

×

UNCOV

2959

    pScanInfo->cleanSttBlocks = isCleanSttBlock(info.pKeyRangeList, &pReader->info.window, pScanInfo, order);

×

UNCOV

2960

    if (pScanInfo->cleanSttBlocks) {

×

UNCOV

2961

      pScanInfo->numOfRowsInStt = info.numOfRows;

×

UNCOV

2964

      for (int32_t i = 0; i < taosArrayGetSize(info.pKeyRangeList); ++i) {

×

UNCOV

2965

        SSttKeyRange* pKeyRange = taosArrayGet(info.pKeyRangeList, i);

×

UNCOV

2966

        if (pKeyRange == NULL) {

×

2967

          continue;

×

UNCOV

2970

        if (pkCompEx(&pScanInfo->sttRange.skey, &pKeyRange->skey) > 0) {

×

UNCOV

2971

          tRowKeyAssign(&pScanInfo->sttRange.skey, &pKeyRange->skey);

×

UNCOV

2974

        if (pkCompEx(&pScanInfo->sttRange.ekey, &pKeyRange->ekey) < 0) {

×

UNCOV

2975

          tRowKeyAssign(&pScanInfo->sttRange.ekey, &pKeyRange->ekey);

×

UNCOV

2979

      pScanInfo->sttKeyInfo.status = taosArrayGetSize(info.pKeyRangeList) ? STT_FILE_HAS_DATA : STT_FILE_NO_DATA;

×

UNCOV

2981

      SRowKey* p = asc ? &pScanInfo->sttRange.skey : &pScanInfo->sttRange.ekey;

×

UNCOV

2982

      tRowKeyAssign(&pScanInfo->sttKeyInfo.nextProcKey, p);

×

UNCOV

2984

      INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window

×

UNCOV

2985

      code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);

×

UNCOV

2986

      if (code != TSDB_CODE_SUCCESS) {

×

2987

        pScanInfo->sttBlockReturned = false;

×

2988

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

2992

    pScanInfo->cleanSttBlocks = false;

×

UNCOV

2993

    INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window

×

UNCOV

2994

    code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);

×

UNCOV

2995

    if (code != TSDB_CODE_SUCCESS) {

×

2996

      pScanInfo->sttBlockReturned = false;

×

2997

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3001

  pScanInfo->sttBlockReturned = false;

×

UNCOV

3002

  int64_t el = taosGetTimestampUs() - st;

×

UNCOV

3003

  pReader->cost.initSttBlockReader += (el / 1000.0);

×

UNCOV

3005

  tsdbDebug("init stt block reader completed, elapsed time:%" PRId64 "us %s", el, pReader->idStr);

×

UNCOV

3007

_end:

×

UNCOV

3008

  if (code != TSDB_CODE_SUCCESS) {

×

3009

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

3010

    if (pReader) {

×

3011

      pReader->code = code;

×

UNCOV

3014

  taosArrayDestroy(info.pKeyRangeList);

×

UNCOV

3015

×

UNCOV

3017

static bool hasDataInSttBlock(STableBlockScanInfo* pInfo) { return pInfo->sttKeyInfo.status == STT_FILE_HAS_DATA; }

×

UNCOV

3019

bool hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo) {

×

UNCOV

3020

  if ((pBlockData->nRow > 0) && (pBlockData->nRow != pDumpInfo->totalRows)) {

×

3021

    return false;  // this is an invalid result.

×

UNCOV

3023

  return pBlockData->nRow > 0 && (!pDumpInfo->allDumped);

×

UNCOV

3026

int32_t mergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pBlockScanInfo, SRowKey* pKey,

×

UNCOV

3028

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

3029

  int32_t             lino = 0;

×

UNCOV

3030

  SRow*               pTSRow = NULL;

×

UNCOV

3031

  SRowMerger*         pMerger = NULL;

×

UNCOV

3032

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

3033

  bool                copied = false;

×

UNCOV

3035

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3036

  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3037

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3039

  pMerger = &pReader->status.merger;

×

UNCOV

3040

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

3042

  code = tryCopyDistinctRowFromFileBlock(pReader, pBlockData, pKey, pDumpInfo, &copied);

×

UNCOV

3043

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3046

  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);

×

UNCOV

3047

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3049

  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);

×

UNCOV

3051

  if (copied) {

×

UNCOV

3052

    goto _end;

×

UNCOV

3055

  TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);

×

UNCOV

3057

  code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

3058

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3060

  code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);

×

UNCOV

3061

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3063

  code = tsdbRowMergerGetRow(pMerger, &pTSRow);

×

UNCOV

3064

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3066

  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);

×

UNCOV

3068

  taosMemoryFreeClear(pTSRow);

×

UNCOV

3069

  tsdbRowMergerClear(pMerger);

×

UNCOV

3070

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3072

_end:

×

UNCOV

3073

  if (code != TSDB_CODE_SUCCESS) {

×

3074

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3076

  return code;

×

UNCOV

3079

int32_t mergeRowsInSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {

×

UNCOV

3080

  int32_t     code = TSDB_CODE_SUCCESS;

×

UNCOV

3081

  int32_t     lino = 0;

×

UNCOV

3082

  SRow*       pTSRow = NULL;

×

UNCOV

3083

  int32_t     pkSrcSlot = 0;

×

UNCOV

3084

  SRowMerger* pMerger = NULL;

×

UNCOV

3085

  bool        copied = false;

×

UNCOV

3087

  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3088

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3089

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3091

  pkSrcSlot = pReader->suppInfo.pkSrcSlot;

×

UNCOV

3092

  pMerger = &pReader->status.merger;

×

UNCOV

3095

  tRowKeyAssign(&pScanInfo->lastProcKey, getCurrentKeyInSttBlock(pSttBlockReader));

×

UNCOV

3097

  TSDBROW* pRow = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

3098

  TSDBROW  fRow = {.iRow = pRow->iRow, .type = TSDBROW_COL_FMT, .pBlockData = pRow->pBlockData};

×

UNCOV

3100

  if (IS_VAR_DATA_TYPE(pScanInfo->lastProcKey.pks[0].type)) {

×

UNCOV

3101

    tsdbTrace("fRow ptr:%p, %d, uid:%" PRIu64 ", ts:%" PRId64 " pk:%s %s", pRow->pBlockData, pRow->iRow,

×

UNCOV

3106

  code = tryCopyDistinctRowFromSttBlock(&fRow, pSttBlockReader, pScanInfo, &pScanInfo->lastProcKey, pReader, &copied);

×

UNCOV

3107

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3109

  if (copied) {

×

UNCOV

3110

    goto _end;

×

UNCOV

3113

  code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

3114

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3116

  TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

3117

  code = tsdbRowMergerAdd(pMerger, pRow1, NULL);

×

UNCOV

3118

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3120

  code = doMergeRowsInSttBlock(pSttBlockReader, pScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange, pReader->idStr);

×

UNCOV

3121

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3123

  code = tsdbRowMergerGetRow(pMerger, &pTSRow);

×

UNCOV

3124

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3126

  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pScanInfo);

×

UNCOV

3128

  taosMemoryFreeClear(pTSRow);

×

UNCOV

3129

  tsdbRowMergerClear(pMerger);

×

UNCOV

3130

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3132

_end:

×

UNCOV

3133

  if (code != TSDB_CODE_SUCCESS) {

×

3134

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3136

  return code;

×

UNCOV

3139

static int32_t buildComposedDataBlockImpl(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo,

×

UNCOV

3141

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

3142

  int32_t             lino = 0;

×

UNCOV

3143

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

3144

  TSDBROW*            pRow = NULL;

×

UNCOV

3145

  TSDBROW*            piRow = NULL;

×

UNCOV

3146

  SRowKey*            pKey = &(SRowKey){0};

×

UNCOV

3148

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3149

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3150

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3152

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

3154

  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {

×

UNCOV

3155

    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pKey);

×

UNCOV

3157

    pKey = NULL;

×

UNCOV

3160

  if (pBlockScanInfo->iter.hasVal) {

×

UNCOV

3161

    code = getValidMemRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader, &pRow);

×

UNCOV

3162

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3165

  if (pBlockScanInfo->iiter.hasVal) {

×

UNCOV

3166

    code = getValidMemRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader, &piRow);

×

UNCOV

3167

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3170

  if (pRow != NULL && piRow != NULL) {

×

UNCOV

3172

    code = doMergeMultiLevelRows(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);

×

UNCOV

3173

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3174

  } else if (pBlockScanInfo->iiter.hasVal) {

×

UNCOV

3176

    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, piRow, &pBlockScanInfo->iiter, pSttBlockReader);

×

UNCOV

3177

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3178

  } else if (pBlockScanInfo->iter.hasVal) {

×

UNCOV

3180

    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, pRow, &pBlockScanInfo->iter, pSttBlockReader);

×

UNCOV

3181

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3184

    code = mergeFileBlockAndSttBlock(pReader, pSttBlockReader, pKey, pBlockScanInfo, pBlockData);

×

UNCOV

3185

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3188

_end:

×

UNCOV

3189

  if (code != TSDB_CODE_SUCCESS) {

×

3190

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3192

  return code;

×

UNCOV

3195

static int32_t loadNeighborIfOverlap(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pBlockScanInfo,

×

UNCOV

3197

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

3198

  int32_t             lino = 0;

×

UNCOV

3199

  int32_t             order = 0;

×

UNCOV

3200

  SDataBlockIter*     pIter = NULL;

×

UNCOV

3201

  SBlockLoadSuppInfo* pSupInfo = NULL;

×

UNCOV

3202

  int32_t             step = 0;

×

UNCOV

3203

  int32_t             nextIndex = -1;

×

UNCOV

3204

  SBrinRecord         rec = {0};

×

UNCOV

3205

  bool                hasNeighbor = false;

×

UNCOV

3207

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3208

  TSDB_CHECK_NULL(loadNeighbor, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3210

  order = pReader->info.order;

×

UNCOV

3211

  pIter = &pReader->status.blockIter;

×

UNCOV

3212

  pSupInfo = &pReader->suppInfo;

×

UNCOV

3213

  step = ASCENDING_TRAVERSE(order) ? 1 : -1;

×

UNCOV

3215

  *loadNeighbor = false;

×

UNCOV

3216

  code = getNeighborBlockOfTable(pIter, pBlockInfo, pBlockScanInfo, &nextIndex, order, &rec, pSupInfo, &hasNeighbor);

×

UNCOV

3217

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3218

  if (!hasNeighbor) {  // do nothing

×

UNCOV

3219

    goto _end;

×

UNCOV

3223

  if (overlapWithNeighborBlock2(pBlockInfo, &rec, order, pReader->suppInfo.pk.type, pReader->suppInfo.numOfPks)) {

×

UNCOV

3224

    SReaderStatus*  pStatus = &pReader->status;

×

UNCOV

3225

    SDataBlockIter* pBlockIter = &pStatus->blockIter;

×

UNCOV

3228

    STableDataBlockIdx* tableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, nextIndex);

×

UNCOV

3229

    TSDB_CHECK_NULL(tableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3232

    int32_t neighborIndex = tableDataBlockIdx->globalIndex;

×

UNCOV

3233

    code = setFileBlockActiveInBlockIter(pReader, pBlockIter, neighborIndex, step);

×

UNCOV

3234

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3237

    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pBlockInfo->uid);

×

UNCOV

3238

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3241

    code = initBlockDumpInfo(pReader, pBlockIter);

×

UNCOV

3242

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3243

    *loadNeighbor = true;

×

UNCOV

3246

_end:

×

UNCOV

3247

  if (code != TSDB_CODE_SUCCESS) {

×

3248

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3250

  return code;

×

UNCOV

3253

void updateComposedBlockInfo(STsdbReader* pReader, double el, STableBlockScanInfo* pBlockScanInfo) {

×

UNCOV

3254

  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

3256

  pResBlock->info.id.uid = (pBlockScanInfo != NULL) ? pBlockScanInfo->uid : 0;

×

UNCOV

3257

  pResBlock->info.dataLoad = 1;

×

UNCOV

3258

  pResBlock->info.version = pReader->info.verRange.maxVer;

×

UNCOV

3260

  int32_t code = blockDataUpdateTsWindow(pResBlock, pReader->suppInfo.slotId[0]);

×

UNCOV

3261

  code = blockDataUpdatePkRange(pResBlock, pReader->suppInfo.pkDstSlot, ASCENDING_TRAVERSE(pReader->info.order));

×

UNCOV

3262

  setComposedBlockFlag(pReader, true);

×

UNCOV

3264

  pReader->cost.composedBlocks += 1;

×

UNCOV

3265

  pReader->cost.buildComposedBlockTime += el;

×

UNCOV

3266

×

UNCOV

3268

static int32_t buildComposedDataBlock(STsdbReader* pReader) {

×

UNCOV

3269

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

3270

  int32_t              lino = 0;

×

UNCOV

3271

  bool                 asc = false;

×

UNCOV

3272

  int64_t              st = 0;

×

UNCOV

3273

  double               el = 0;

×

UNCOV

3274

  int32_t              step = 0;

×

UNCOV

3275

  SSDataBlock*         pResBlock = NULL;

×

UNCOV

3276

  SFileDataBlockInfo*  pBlockInfo = NULL;

×

UNCOV

3277

  SSttBlockReader*     pSttBlockReader = NULL;

×

UNCOV

3278

  SFileBlockDumpInfo*  pDumpInfo = NULL;

×

UNCOV

3279

  STableBlockScanInfo* pBlockScanInfo = NULL;

×

UNCOV

3282

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3284

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

3285

  st = taosGetTimestampUs();

×

UNCOV

3286

  step = asc ? 1 : -1;

×

UNCOV

3287

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

3288

  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;

×

UNCOV

3289

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

3291

  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

3292

  if (code != TSDB_CODE_SUCCESS) {

×

3293

    return 0;

×

UNCOV

3296

  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {

×

3297

    setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);

×

3298

    return code;

×

UNCOV

3301

  code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);

×

UNCOV

3302

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3304

  code = getCurrentKeyInBuf(pBlockScanInfo, pReader, &keyInBuf);

×

UNCOV

3305

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3308

  int64_t cap = pReader->resBlockInfo.capacity;

×

UNCOV

3309

  bool    isClean = false;

×

UNCOV

3310

  code = isCleanFileDataBlock(pReader, pBlockInfo, pBlockScanInfo, keyInBuf, &isClean);

×

UNCOV

3311

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3312

  bool directCopy = isClean && (pBlockInfo->numRow <= cap) && (pBlockScanInfo->sttKeyInfo.status == STT_FILE_NO_DATA) &&

×

UNCOV

3313

                    ((asc && ((pBlockInfo->lastKey < keyInBuf.ts) || (keyInBuf.ts == INT64_MIN))) ||

×

UNCOV

3314

                     (!asc && (pBlockInfo->lastKey > keyInBuf.ts)));

×

UNCOV

3315

  if (directCopy) {

×

UNCOV

3316

    code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);

×

UNCOV

3317

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3318

    goto _end;

×

UNCOV

3321

  SBlockData* pBlockData = &pReader->status.fileBlockData;

×

UNCOV

3322

  initSttBlockReader(pSttBlockReader, pBlockScanInfo, pReader);

×

UNCOV

3323

  code = pReader->code;

×

UNCOV

3324

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3326

  while (1) {

×

UNCOV

3327

    bool hasBlockData = false;

×

UNCOV

3329

      while (pBlockData->nRow > 0 && pBlockData->uid == pBlockScanInfo->uid) {

×

UNCOV

3331

        bool valid = false;

×

UNCOV

3333

            isValidFileBlockRow(pBlockData, pDumpInfo->rowIndex, pBlockScanInfo, asc, &pReader->info, pReader, &valid);

×

UNCOV

3334

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3335

        if (valid) {

×

UNCOV

3336

          hasBlockData = true;

×

UNCOV

3337

          break;

×

UNCOV

3340

        pDumpInfo->rowIndex += step;

×

UNCOV

3342

        if (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0) {

×

3344

          code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

3345

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3349

          bool loadNeighbor = false;

×

UNCOV

3350

          code = loadNeighborIfOverlap(pBlockInfo, pBlockScanInfo, pReader, &loadNeighbor);

×

UNCOV

3351

          if ((!loadNeighbor) || (code != 0)) {

×

UNCOV

3352

            lino = __LINE__;

×

UNCOV

3353

            setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);

×

UNCOV

3354

            break;

×

UNCOV

3361

    if (hasBlockData == false) {

×

UNCOV

3362

      break;

×

UNCOV

3365

    code = buildComposedDataBlockImpl(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);

×

UNCOV

3366

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3369

    if ((pBlockData->nRow > 0) && (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0)) {

×

UNCOV

3370

      setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);

×

UNCOV

3371

      break;

×

UNCOV

3374

    if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {

×

UNCOV

3375

      break;

×

UNCOV

3379

_end:

×

UNCOV

3380

  if (pReader) {

×

UNCOV

3381

    el = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

3382

    updateComposedBlockInfo(pReader, el, pBlockScanInfo);

×

UNCOV

3385

  if (pResBlock && pResBlock->info.rows > 0) {

×

UNCOV

3386

    tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64

×

UNCOV

3392

  if (code != TSDB_CODE_SUCCESS) {

×

3393

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3395

  return code;

×

UNCOV

3398

void setComposedBlockFlag(STsdbReader* pReader, bool composed) { pReader->status.composedDataBlock = composed; }

×

UNCOV

3400

int32_t getInitialDelIndex(const SArray* pDelSkyline, int32_t order) {

×

UNCOV

3401

  if (pDelSkyline == NULL) {

×

3402

    return 0;

×

UNCOV

3405

  return ASCENDING_TRAVERSE(order) ? 0 : taosArrayGetSize(pDelSkyline) - 1;

×

UNCOV

3408

int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, int32_t order, SReadCostSummary* pCost) {

×

UNCOV

3409

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

3410

  int32_t lino = 0;

×

UNCOV

3411

  int32_t newDelDataInFile = 0;

×

UNCOV

3412

  int64_t st = 0;

×

UNCOV

3413

  SArray* pSource = NULL;

×

UNCOV

3415

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3417

  newDelDataInFile = taosArrayGetSize(pBlockScanInfo->pFileDelData);

×

UNCOV

3418

  if (newDelDataInFile == 0 &&

×

UNCOV

3419

      ((pBlockScanInfo->delSkyline != NULL) || (TARRAY_SIZE(pBlockScanInfo->pMemDelData) == 0))) {

×

UNCOV

3420

    goto _end;

×

UNCOV

3423

  st = taosGetTimestampUs();

×

UNCOV

3425

  if (pBlockScanInfo->delSkyline != NULL) {

×

UNCOV

3426

    taosArrayClear(pBlockScanInfo->delSkyline);

×

UNCOV

3428

    pBlockScanInfo->delSkyline = taosArrayInit(4, sizeof(TSDBKEY));

×

UNCOV

3429

    TSDB_CHECK_NULL(pBlockScanInfo->delSkyline, code, lino, _end, terrno);

×

UNCOV

3432

  pSource = pBlockScanInfo->pFileDelData;

×

UNCOV

3433

  if (pSource == NULL) {

×

UNCOV

3434

    pSource = pBlockScanInfo->pMemDelData;

×

UNCOV

3436

    const void* p1 = taosArrayAddAll(pSource, pBlockScanInfo->pMemDelData);

×

UNCOV

3437

    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

3440

  code = tsdbBuildDeleteSkyline(pSource, 0, taosArrayGetSize(pSource) - 1, pBlockScanInfo->delSkyline);

×

UNCOV

3442

  taosArrayClear(pBlockScanInfo->pFileDelData);

×

UNCOV

3443

  int32_t index = getInitialDelIndex(pBlockScanInfo->delSkyline, order);

×

UNCOV

3445

  pBlockScanInfo->iter.index = index;

×

UNCOV

3446

  pBlockScanInfo->iiter.index = index;

×

UNCOV

3447

  pBlockScanInfo->fileDelIndex = index;

×

UNCOV

3448

  pBlockScanInfo->sttBlockDelIndex = index;

×

UNCOV

3449

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3451

  TSDB_CHECK_NULL(pCost, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3452

  double el = taosGetTimestampUs() - st;

×

UNCOV

3453

  pCost->createSkylineIterTime = el / 1000.0;

×

UNCOV

3455

_end:

×

UNCOV

3456

  if (code != TSDB_CODE_SUCCESS) {

×

3457

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3459

  return code;

×

UNCOV

3462

int32_t getCurrentKeyInBuf(STableBlockScanInfo* pScanInfo, STsdbReader* pReader, TSDBKEY* pkey) {

×

UNCOV

3463

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

3464

  int32_t  lino = 0;

×

UNCOV

3465

  bool     asc = false;

×

UNCOV

3466

  bool     hasKey = false;

×

UNCOV

3467

  bool     hasIKey = false;

×

UNCOV

3468

  TSDBROW* pRow = NULL;

×

UNCOV

3469

  TSDBROW* pIRow = NULL;

×

UNCOV

3470

  TSDBKEY  key = {.ts = TSKEY_INITIAL_VAL};

×

UNCOV

3471

  TSDBKEY  ikey = {.ts = TSKEY_INITIAL_VAL};

×

UNCOV

3473

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3474

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3475

  TSDB_CHECK_NULL(pkey, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3477

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

3479

  code = getValidMemRow(&pScanInfo->iter, pScanInfo->delSkyline, pReader, &pRow);

×

UNCOV

3480

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3481

  if (pRow != NULL) {

×

UNCOV

3482

    hasKey = true;

×

UNCOV

3483

    key = TSDBROW_KEY(pRow);

×

UNCOV

3486

  code = getValidMemRow(&pScanInfo->iiter, pScanInfo->delSkyline, pReader, &pIRow);

×

UNCOV

3487

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3488

  if (pIRow != NULL) {

×

UNCOV

3489

    hasIKey = true;

×

UNCOV

3490

    ikey = TSDBROW_KEY(pIRow);

×

UNCOV

3493

  if (hasKey) {

×

UNCOV

3494

    if (hasIKey) {  // has data in mem & imem

×

UNCOV

3495

      if (asc) {

×

UNCOV

3496

        *pkey = key.ts <= ikey.ts ? key : ikey;

×

3498

        *pkey = key.ts <= ikey.ts ? ikey : key;

×

UNCOV

3501

      *pkey = key;

×

UNCOV

3506

    *pkey = ikey;

×

UNCOV

3509

_end:

×

UNCOV

3510

  if (code != TSDB_CODE_SUCCESS) {

×

3511

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3513

  return code;

×

UNCOV

3516

static void prepareDurationForNextFileSet(STsdbReader* pReader) {

×

UNCOV

3517

  if (pReader->status.bProcMemFirstFileset) {

×

UNCOV

3518

    pReader->status.prevFilesetStartKey = INT64_MIN;

×

UNCOV

3519

    pReader->status.prevFilesetEndKey = INT64_MAX;

×

UNCOV

3520

    pReader->status.bProcMemFirstFileset = false;

×

UNCOV

3523

  int32_t     fid = pReader->status.pCurrentFileset->fid;

×

UNCOV

3524

  STimeWindow winFid = {0};

×

UNCOV

3525

  tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &winFid.skey, &winFid.ekey);

×

UNCOV

3527

  if (ASCENDING_TRAVERSE(pReader->info.order)) {

×

UNCOV

3528

    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < pReader->status.prevFilesetStartKey ||

×

UNCOV

3529

                                           (winFid.skey - 1) < pReader->status.memTableMinKey);

×

UNCOV

3531

    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < (winFid.ekey + 1) ||

×

UNCOV

3532

                                           pReader->status.prevFilesetEndKey < pReader->status.memTableMinKey);

×

UNCOV

3535

  if (pReader->status.bProcMemPreFileset) {

×

UNCOV

3536

    tsdbDebug("will start pre-fileset %d buffer processing. %s", fid, pReader->idStr);

×

UNCOV

3537

    pReader->status.procMemUidList.tableUidList = pReader->status.uidList.tableUidList;

×

UNCOV

3538

    resetPreFilesetMemTableListIndex(&pReader->status);

×

UNCOV

3541

  if (!pReader->status.bProcMemPreFileset) {

×

UNCOV

3542

    if (pReader->notifyFn) {

×

UNCOV

3543

      STsdReaderNotifyInfo info = {0};

×

UNCOV

3544

      info.duration.filesetId = fid;

×

UNCOV

3545

      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);

×

UNCOV

3546

      tsdbDebug("new duration %d start notification when no buffer preceeding fileset, %s", fid, pReader->idStr);

×

UNCOV

3550

  pReader->status.prevFilesetStartKey = winFid.skey;

×

UNCOV

3551

  pReader->status.prevFilesetEndKey = winFid.ekey;

×

UNCOV

3552

×

UNCOV

3554

static int32_t moveToNextFile(STsdbReader* pReader, SBlockNumber* pBlockNum, SArray* pTableList) {

×

UNCOV

3555

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

3556

  int32_t        lino = 0;

×

UNCOV

3557

  SReaderStatus* pStatus = NULL;

×

UNCOV

3558

  SArray*        pIndexList = NULL;

×

UNCOV

3559

  size_t         numOfTables = 0;

×

UNCOV

3561

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3562

  TSDB_CHECK_NULL(pBlockNum, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3564

  pStatus = &pReader->status;

×

UNCOV

3565

  pBlockNum->numOfBlocks = 0;

×

UNCOV

3566

  pBlockNum->numOfSttFiles = 0;

×

UNCOV

3568

  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

3569

  pIndexList = taosArrayInit(numOfTables, sizeof(SBrinBlk));

×

UNCOV

3570

  TSDB_CHECK_NULL(pIndexList, code, lino, _end, terrno);

×

UNCOV

3572

  while (1) {

×

UNCOV

3574

    if (pReader->code != TSDB_CODE_SUCCESS) {

×

3575

      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);

×

3576

      code = pReader->code;

×

3577

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3580

    bool hasNext = false;

×

UNCOV

3581

    code = filesetIteratorNext(&pStatus->fileIter, pReader, &hasNext);

×

UNCOV

3582

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3584

    if (!hasNext) {  // no data files on disk

×

UNCOV

3585

      break;

×

UNCOV

3588

    taosArrayClear(pIndexList);

×

UNCOV

3589

    code = doLoadBlockIndex(pReader, pReader->pFileReader, pIndexList);

×

UNCOV

3590

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3592

    if (taosArrayGetSize(pIndexList) > 0 || pReader->status.pCurrentFileset->lvlArr->size > 0) {

×

UNCOV

3593

      code = loadFileBlockBrinInfo(pReader, pIndexList, pBlockNum, pTableList);

×

UNCOV

3594

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3596

      if (pBlockNum->numOfBlocks + pBlockNum->numOfSttFiles > 0) {

×

UNCOV

3597

        if (pReader->bFilesetDelimited) {

×

UNCOV

3598

          prepareDurationForNextFileSet(pReader);

×

UNCOV

3600

        break;

×

UNCOV

3607

  code = loadDataFileTombDataForAll(pReader);

×

UNCOV

3608

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3610

_end:

×

UNCOV

3611

  if (code != TSDB_CODE_SUCCESS) {

×

3612

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3614

  if (pIndexList) {

×

UNCOV

3615

    taosArrayDestroy(pIndexList);

×

UNCOV

3617

  return code;

×

UNCOV

3621

static int32_t resetTableListIndex(SReaderStatus* pStatus, const char* id) {

×

UNCOV

3622

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

3623

  int32_t        lino = 0;

×

UNCOV

3624

  STableUidList* pList = NULL;

×

UNCOV

3626

  TSDB_CHECK_NULL(pStatus, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3628

  pList = &pStatus->uidList;

×

UNCOV

3630

  pList->currentIndex = 0;

×

UNCOV

3631

  uint64_t uid = pList->tableUidList[0];

×

UNCOV

3632

  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));

×

UNCOV

3633

  if (pStatus->pTableIter == NULL) {

×

3634

    tsdbError("%s failed to load tableBlockScanInfo for uid:%" PRId64 ", code: internal error", id, uid);

×

3635

    TSDB_CHECK_NULL(pStatus->pTableIter, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);

×

UNCOV

3638

_end:

×

UNCOV

3639

  if (code != TSDB_CODE_SUCCESS) {

×

3640

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3642

  return code;

×

UNCOV

3645

static void resetPreFilesetMemTableListIndex(SReaderStatus* pStatus) {

×

UNCOV

3646

  STableUidList* pList = &pStatus->procMemUidList;

×

UNCOV

3648

  pList->currentIndex = 0;

×

UNCOV

3649

  uint64_t uid = pList->tableUidList[0];

×

UNCOV

3650

  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));

×

UNCOV

3651

×

UNCOV

3653

static bool moveToNextTable(STableUidList* pOrderedCheckInfo, SReaderStatus* pStatus) {

×

UNCOV

3654

  pOrderedCheckInfo->currentIndex += 1;

×

UNCOV

3655

  if (pOrderedCheckInfo->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {

×

UNCOV

3656

    pStatus->pTableIter = NULL;

×

UNCOV

3657

    return false;

×

UNCOV

3660

  uint64_t uid = pOrderedCheckInfo->tableUidList[pOrderedCheckInfo->currentIndex];

×

UNCOV

3661

  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));

×

UNCOV

3662

  return (pStatus->pTableIter != NULL);

×

UNCOV

3665

static bool moveToNextTableForPreFileSetMem(SReaderStatus* pStatus) {

×

UNCOV

3666

  STableUidList* pUidList = &pStatus->procMemUidList;

×

UNCOV

3667

  pUidList->currentIndex += 1;

×

UNCOV

3668

  if (pUidList->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {

×

UNCOV

3669

    pStatus->pProcMemTableIter = NULL;

×

UNCOV

3670

    return false;

×

UNCOV

3673

  uint64_t uid = pUidList->tableUidList[pUidList->currentIndex];

×

UNCOV

3674

  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));

×

UNCOV

3675

  return (pStatus->pProcMemTableIter != NULL);

×

UNCOV

3678

static int32_t buildCleanBlockFromSttFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo) {

×

UNCOV

3679

  int32_t          code = TSDB_CODE_SUCCESS;

×

UNCOV

3680

  int32_t          lino = 0;

×

UNCOV

3681

  SReaderStatus*   pStatus = NULL;

×

UNCOV

3682

  SSttBlockReader* pSttBlockReader = NULL;

×

UNCOV

3683

  SSDataBlock*     pResBlock = NULL;

×

UNCOV

3684

  SDataBlockInfo*  pInfo = NULL;

×

UNCOV

3685

  bool             asc = false;

×

UNCOV

3687

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3688

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3690

  pStatus = &pReader->status;

×

UNCOV

3691

  pSttBlockReader = pStatus->fileIter.pSttBlockReader;

×

UNCOV

3692

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

3694

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

3695

  code = blockDataEnsureCapacity(pResBlock, pScanInfo->numOfRowsInStt);

×

UNCOV

3696

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3698

  pInfo = &pResBlock->info;

×

UNCOV

3699

  pInfo->rows = pScanInfo->numOfRowsInStt;

×

UNCOV

3700

  pInfo->id.uid = pScanInfo->uid;

×

UNCOV

3701

  pInfo->dataLoad = 1;

×

UNCOV

3702

  pInfo->window.skey = pScanInfo->sttRange.skey.ts;

×

UNCOV

3703

  pInfo->window.ekey = pScanInfo->sttRange.ekey.ts;

×

UNCOV

3705

  setComposedBlockFlag(pReader, true);

×

UNCOV

3707

  pScanInfo->sttKeyInfo.nextProcKey.ts = asc ? pScanInfo->sttRange.ekey.ts + 1 : pScanInfo->sttRange.skey.ts - 1;

×

UNCOV

3708

  pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;

×

UNCOV

3710

  if (asc) {

×

UNCOV

3711

    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.ekey);

×

3713

    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.skey);

×

UNCOV

3716

  pScanInfo->sttBlockReturned = true;

×

UNCOV

3717

  pSttBlockReader->mergeTree.pIter = NULL;

×

UNCOV

3719

  tsdbDebug("%p uid:%" PRId64 " return clean stt block as one, brange:%" PRId64 "-%" PRId64 " rows:%" PRId64 " %s",

×

UNCOV

3723

_end:

×

UNCOV

3724

  if (code != TSDB_CODE_SUCCESS) {

×

3725

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3727

  return code;

×

UNCOV

3730

static int32_t buildCleanBlockFromDataFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,

×

UNCOV

3732

  int32_t         code = TSDB_CODE_SUCCESS;

×

UNCOV

3733

  int32_t         lino = 0;

×

UNCOV

3734

  SReaderStatus*  pStatus = NULL;

×

UNCOV

3735

  SDataBlockInfo* pInfo = NULL;

×

UNCOV

3736

  bool            asc = false;

×

UNCOV

3738

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3739

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3740

  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3743

  pStatus = &pReader->status;

×

UNCOV

3744

  pInfo = &pReader->resBlockInfo.pResBlock->info;

×

UNCOV

3745

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

3747

  pInfo->rows = pBlockInfo->numRow;

×

UNCOV

3748

  pInfo->id.uid = pScanInfo->uid;

×

UNCOV

3749

  pInfo->dataLoad = 0;

×

UNCOV

3750

  pInfo->version = pReader->info.verRange.maxVer;

×

UNCOV

3751

  pInfo->window = (STimeWindow){.skey = pBlockInfo->firstKey, .ekey = pBlockInfo->lastKey};

×

UNCOV

3753

  if (pReader->suppInfo.numOfPks > 0) {

×

UNCOV

3754

    if (IS_NUMERIC_TYPE(pReader->suppInfo.pk.type)) {

×

UNCOV

3755

      pInfo->pks[0].val = pBlockInfo->firstPk.val;

×

UNCOV

3756

      pInfo->pks[1].val = pBlockInfo->lastPk.val;

×

3758

      (void)memcpy(pInfo->pks[0].pData, varDataVal(pBlockInfo->firstPk.pData), varDataLen(pBlockInfo->firstPk.pData));

×

3759

      (void)memcpy(pInfo->pks[1].pData, varDataVal(pBlockInfo->lastPk.pData), varDataLen(pBlockInfo->lastPk.pData));

×

3761

      pInfo->pks[0].nData = varDataLen(pBlockInfo->firstPk.pData);

×

3762

      pInfo->pks[1].nData = varDataLen(pBlockInfo->lastPk.pData);

×

UNCOV

3767

  setComposedBlockFlag(pReader, false);

×

UNCOV

3768

  setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);

×

UNCOV

3769

  code = updateLastKeyInfo(&pScanInfo->lastProcKey, pBlockInfo, pInfo, pReader->suppInfo.numOfPks, asc);

×

UNCOV

3770

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3772

  tsdbDebug("%p uid:%" PRIu64

×

UNCOV

3778

_end:

×

UNCOV

3779

  if (code != TSDB_CODE_SUCCESS) {

×

3780

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3782

  return code;

×

UNCOV

3785

static int32_t doLoadSttBlockSequentially(STsdbReader* pReader) {

×

UNCOV

3786

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

3787

  int32_t              lino = 0;

×

UNCOV

3788

  SReaderStatus*       pStatus = NULL;

×

UNCOV

3789

  SSttBlockReader*     pSttBlockReader = NULL;

×

UNCOV

3790

  STableUidList*       pUidList = NULL;

×

UNCOV

3791

  SSDataBlock*         pResBlock = NULL;

×

UNCOV

3792

  STableBlockScanInfo* pScanInfo = NULL;

×

UNCOV

3794

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3796

  pStatus = &pReader->status;

×

UNCOV

3797

  pSttBlockReader = pStatus->fileIter.pSttBlockReader;

×

UNCOV

3798

  pUidList = &pStatus->uidList;

×

UNCOV

3800

  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {

×

3801

    goto _end;

×

UNCOV

3804

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

3806

  while (1) {

×

UNCOV

3807

    if (pReader->code != TSDB_CODE_SUCCESS) {

×

3808

      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);

×

3809

      code = pReader->code;

×

3810

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3814

    if (pStatus->pTableIter == NULL) {

×

3815

      tsdbError("table Iter is null, invalid pScanInfo, try next table %s", pReader->idStr);

×

3816

      bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

3817

      if (!hasNexTable) {

×

3818

        break;

×

3821

      continue;

×

UNCOV

3823

      pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;

×

UNCOV

3826

    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {

×

UNCOV

3828

      bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

UNCOV

3829

      if (!hasNexTable) {

×

UNCOV

3830

        break;

×

UNCOV

3833

      continue;

×

UNCOV

3836

    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);

×

UNCOV

3837

    code = pReader->code;

×

UNCOV

3838

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3840

    if (!hasDataInSttBlock(pScanInfo)) {

×

UNCOV

3841

      bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

UNCOV

3842

      if (!hasNexTable) {

×

UNCOV

3843

        break;

×

UNCOV

3846

      continue;

×

UNCOV

3850

    if (pReader->info.execMode == READER_EXEC_ROWS && pScanInfo->cleanSttBlocks) {

×

UNCOV

3851

      code = buildCleanBlockFromSttFiles(pReader, pScanInfo);

×

UNCOV

3852

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3853

      break;

×

UNCOV

3856

    int64_t st = taosGetTimestampUs();

×

UNCOV

3859

      if (!hasDataInSttBlock(pScanInfo)) {

×

UNCOV

3860

        break;

×

UNCOV

3863

      code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);

×

UNCOV

3864

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3866

      if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {

×

UNCOV

3867

        break;

×

UNCOV

3871

    double el = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

3872

    updateComposedBlockInfo(pReader, el, pScanInfo);

×

UNCOV

3874

    if (pResBlock->info.rows > 0) {

×

UNCOV

3875

      tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64

×

UNCOV

3879

      break;

×

3883

    bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

3884

    if (!hasNexTable) {

×

3885

      break;

×

UNCOV

3889

_end:

×

UNCOV

3890

  if (code != TSDB_CODE_SUCCESS) {

×

3891

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

3893

  return code;

×

UNCOV

3897

static bool notOverlapWithFiles(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pScanInfo, bool asc) {

×

UNCOV

3898

  if ((!hasDataInSttBlock(pScanInfo)) || (pScanInfo->cleanSttBlocks == true)) {

×

UNCOV

3899

    return true;

×

UNCOV

3901

    int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

3902

    return (asc && pBlockInfo->lastKey < keyInStt) || (!asc && pBlockInfo->firstKey > keyInStt);

×

UNCOV

3906

static int32_t doBuildDataBlock(STsdbReader* pReader) {

×

UNCOV

3907

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

3908

  int32_t              lino = 0;

×

UNCOV

3909

  SReaderStatus*       pStatus = NULL;

×

UNCOV

3910

  SDataBlockIter*      pBlockIter = NULL;

×

UNCOV

3911

  STableBlockScanInfo* pScanInfo = NULL;

×

UNCOV

3912

  SFileDataBlockInfo*  pBlockInfo = NULL;

×

UNCOV

3913

  SSttBlockReader*     pSttBlockReader = NULL;

×

UNCOV

3915

  bool                 asc = false;

×

UNCOV

3917

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

3919

  pStatus = &pReader->status;

×

UNCOV

3920

  pBlockIter = &pStatus->blockIter;

×

UNCOV

3921

  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;

×

UNCOV

3922

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

3924

  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

3925

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3927

  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {

×

UNCOV

3928

    setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);

×

UNCOV

3929

    goto _end;

×

UNCOV

3932

  code = pReader->code;

×

UNCOV

3933

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3935

  code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pScanInfo, pReader->idStr);

×

UNCOV

3936

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3938

  if (pScanInfo->sttKeyInfo.status == STT_FILE_READER_UNINIT) {

×

UNCOV

3939

    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);

×

UNCOV

3940

    code = pReader->code;

×

UNCOV

3941

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3944

  code = getCurrentKeyInBuf(pScanInfo, pReader, &keyInBuf);

×

UNCOV

3945

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3946

  bool load = false;

×

UNCOV

3947

  code = fileBlockShouldLoad(pReader, pBlockInfo, pScanInfo, keyInBuf, &load);

×

UNCOV

3948

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3949

  if (load) {

×

UNCOV

3950

    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pScanInfo->uid);

×

UNCOV

3951

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3954

    code = buildComposedDataBlock(pReader);

×

UNCOV

3955

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3956

  } else if (bufferDataInFileBlockGap(keyInBuf, pBlockInfo, pScanInfo, pReader->info.order)) {

×

UNCOV

3959

    int64_t endKey = getBoarderKeyInFiles(pBlockInfo, pScanInfo, pReader->info.order);

×

UNCOV

3960

    code = buildDataBlockFromBuf(pReader, pScanInfo, endKey);

×

UNCOV

3961

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3963

    if (notOverlapWithFiles(pBlockInfo, pScanInfo, asc)) {

×

UNCOV

3964

      int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;

×

UNCOV

3966

      if ((!hasDataInSttBlock(pScanInfo)) || (asc && pBlockInfo->lastKey < keyInStt) ||

×

UNCOV

3967

          (!asc && pBlockInfo->firstKey > keyInStt)) {

×

UNCOV

3970

        code = buildCleanBlockFromDataFiles(pReader, pScanInfo, pBlockInfo, pBlockIter->index);

×

UNCOV

3971

        TSDB_CHECK_CODE(code, lino, _end);

×

3973

        TSDB_CHECK_CONDITION((pReader->info.execMode == READER_EXEC_ROWS) && (pSttBlockReader->mergeTree.pIter == NULL),

×

3975

        code = buildCleanBlockFromSttFiles(pReader, pScanInfo);

×

3976

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3979

      SBlockData* pBData = &pReader->status.fileBlockData;

×

UNCOV

3980

      tBlockDataReset(pBData);

×

UNCOV

3982

      SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

3984

      tsdbDebug("load data in stt block firstly %s", pReader->idStr);

×

UNCOV

3985

      int64_t st = taosGetTimestampUs();

×

UNCOV

3988

      initSttBlockReader(pSttBlockReader, pScanInfo, pReader);

×

UNCOV

3989

      code = pReader->code;

×

UNCOV

3990

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

3993

      while (hasDataInSttBlock(pScanInfo)) {

×

UNCOV

3994

        TSDB_CHECK_CONDITION(pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA, code, lino, _end,

×

UNCOV

3997

        code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);

×

UNCOV

3998

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4000

        if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {

×

UNCOV

4001

          break;

×

UNCOV

4005

        SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

4006

        if ((pSttKey->ts >= pBlockInfo->firstKey && asc) || (pSttKey->ts <= pBlockInfo->lastKey && (!asc))) {

×

UNCOV

4007

          tsdbDebug("%p lastKeyInStt:%" PRId64 ", overlap with file block, brange:%" PRId64 "-%" PRId64 " %s", pReader,

×

UNCOV

4009

          break;

×

UNCOV

4013

      double el = (taosGetTimestampUs() - st) / 1000.0;

×

UNCOV

4014

      updateComposedBlockInfo(pReader, el, pScanInfo);

×

UNCOV

4016

      if (pResBlock->info.rows > 0) {

×

UNCOV

4017

        tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64

×

UNCOV

4025

  code = pReader->code;

×

UNCOV

4026

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4028

_end:

×

UNCOV

4029

  if (code != TSDB_CODE_SUCCESS) {

×

4030

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4032

  return code;

×

UNCOV

4035

static int32_t buildBlockFromBufferSeqForPreFileset(STsdbReader* pReader, int64_t endKey) {

×

UNCOV

4036

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

4037

  int32_t        lino = 0;

×

UNCOV

4038

  SReaderStatus* pStatus = NULL;

×

UNCOV

4040

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4042

  pStatus = &pReader->status;

×

UNCOV

4044

  tsdbDebug("seq load data blocks from cache that preceeds fileset %d, %s", pReader->status.pCurrentFileset->fid,

×

UNCOV

4047

  while (1) {

×

UNCOV

4048

    if (pReader->code != TSDB_CODE_SUCCESS) {

×

4049

      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);

×

4050

      code = pReader->code;

×

4051

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4054

    STableBlockScanInfo** pBlockScanInfo = pStatus->pProcMemTableIter;

×

UNCOV

4055

    if (pReader->pIgnoreTables &&

×

UNCOV

4056

        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {

×

UNCOV

4057

      bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);

×

UNCOV

4058

      if (!hasNexTable) {

×

4059

        break;

×

UNCOV

4061

      continue;

×

UNCOV

4064

    code = initMemDataIterator(*pBlockScanInfo, pReader);

×

UNCOV

4065

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4067

    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);

×

UNCOV

4068

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4070

    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);

×

UNCOV

4071

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4073

    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {

×

UNCOV

4074

      break;

×

UNCOV

4078

    bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);

×

UNCOV

4079

    if (!hasNexTable) {

×

UNCOV

4080

      break;

×

UNCOV

4084

_end:

×

UNCOV

4085

  if (code != TSDB_CODE_SUCCESS) {

×

4086

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4088

  return code;

×

UNCOV

4091

static int32_t buildBlockFromBufferSequentially(STsdbReader* pReader, int64_t endKey) {

×

UNCOV

4092

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

4093

  int32_t        lino = 0;

×

UNCOV

4094

  SReaderStatus* pStatus = NULL;

×

UNCOV

4095

  STableUidList* pUidList = NULL;

×

UNCOV

4097

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4099

  pStatus = &pReader->status;

×

UNCOV

4100

  pUidList = &pStatus->uidList;

×

UNCOV

4102

  tsdbDebug("seq load data blocks from cache, %s", pReader->idStr);

×

UNCOV

4104

  while (1) {

×

UNCOV

4105

    if (pReader->code != TSDB_CODE_SUCCESS) {

×

4106

      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);

×

UNCOV

4107

      code = pReader->code;

×

UNCOV

4108

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4111

    STableBlockScanInfo** pBlockScanInfo = pStatus->pTableIter;

×

UNCOV

4112

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

×

UNCOV

4116

    if (pReader->pIgnoreTables &&

×

UNCOV

4117

        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {

×

UNCOV

4118

      bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

UNCOV

4119

      if (!hasNexTable) {

×

UNCOV

4120

        break;

×

UNCOV

4122

      continue;

×

UNCOV

4125

    code = initMemDataIterator(*pBlockScanInfo, pReader);

×

UNCOV

4126

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4128

    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);

×

UNCOV

4129

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4131

    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);

×

UNCOV

4132

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4134

    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {

×

UNCOV

4135

      break;

×

UNCOV

4139

    bool hasNexTable = moveToNextTable(pUidList, pStatus);

×

UNCOV

4140

    if (!hasNexTable) {

×

UNCOV

4141

      break;

×

4145

_end:

×

UNCOV

4146

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

4147

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4149

  return code;

×

UNCOV

4153

static int32_t initBlockDumpInfo(STsdbReader* pReader, SDataBlockIter* pBlockIter) {

×

UNCOV

4154

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

4155

  int32_t             lino = 0;

×

UNCOV

4156

  SFileDataBlockInfo* pBlockInfo = NULL;

×

UNCOV

4157

  SReaderStatus*      pStatus = NULL;

×

UNCOV

4158

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

4160

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4162

  pStatus = &pReader->status;

×

UNCOV

4163

  pDumpInfo = &pStatus->fBlockDumpInfo;

×

UNCOV

4165

  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

4166

  if (code == TSDB_CODE_SUCCESS) {

×

UNCOV

4167

    pDumpInfo->totalRows = pBlockInfo->numRow;

×

UNCOV

4168

    pDumpInfo->rowIndex = ASCENDING_TRAVERSE(pReader->info.order) ? 0 : pBlockInfo->numRow - 1;

×

UNCOV

4170

    pDumpInfo->totalRows = 0;

×

UNCOV

4171

    pDumpInfo->rowIndex = 0;

×

UNCOV

4172

    code = TSDB_CODE_SUCCESS;

×

UNCOV

4175

  pDumpInfo->allDumped = false;

×

UNCOV

4177

_end:

×

UNCOV

4178

  if (code != TSDB_CODE_SUCCESS) {

×

4179

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4181

  return code;

×

UNCOV

4184

static int32_t initForFirstBlockInFile(STsdbReader* pReader, SDataBlockIter* pBlockIter) {

×

UNCOV

4185

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

4186

  int32_t      lino = 0;

×

UNCOV

4187

  SBlockNumber num = {0};

×

UNCOV

4188

  SArray*      pTableList = NULL;

×

UNCOV

4190

  pTableList = taosArrayInit(40, POINTER_BYTES);

×

UNCOV

4191

  TSDB_CHECK_NULL(pTableList, code, lino, _end, terrno);

×

UNCOV

4193

  code = moveToNextFile(pReader, &num, pTableList);

×

UNCOV

4194

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4197

  if (num.numOfBlocks + num.numOfSttFiles == 0) {

×

UNCOV

4198

    pReader->status.loadFromFile = false;

×

UNCOV

4199

    goto _end;

×

UNCOV

4203

  if (num.numOfBlocks > 0) {

×

UNCOV

4204

    code = initBlockIterator(pReader, pBlockIter, num.numOfBlocks, pTableList);

×

UNCOV

4205

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4207

    tBlockDataReset(&pReader->status.fileBlockData);

×

UNCOV

4208

    code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);

×

UNCOV

4209

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4211

    code = resetTableListIndex(&pReader->status, pReader->idStr);

×

UNCOV

4212

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4215

  code = initBlockDumpInfo(pReader, pBlockIter);

×

UNCOV

4216

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4218

_end:

×

UNCOV

4219

  if (code != TSDB_CODE_SUCCESS) {

×

4220

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4222

  if (pTableList) {

×

UNCOV

4223

    taosArrayDestroy(pTableList);

×

UNCOV

4225

  return code;

×

UNCOV

4228

static bool fileBlockPartiallyRead(SFileBlockDumpInfo* pDumpInfo, bool asc) {

×

UNCOV

4229

  return (!pDumpInfo->allDumped) &&

×

UNCOV

4230

         ((pDumpInfo->rowIndex > 0 && asc) || (pDumpInfo->rowIndex < (pDumpInfo->totalRows - 1) && (!asc)));

×

UNCOV

4238

static int32_t doReadDataFromSttFiles(STsdbReader* pReader, ERetrieveType* pReturnType) {

×

UNCOV

4239

  int32_t         code = TSDB_CODE_SUCCESS;

×

UNCOV

4240

  int32_t         lino = 0;

×

UNCOV

4241

  SSDataBlock*    pResBlock = NULL;

×

UNCOV

4242

  SDataBlockIter* pBlockIter = NULL;

×

UNCOV

4244

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4245

  TSDB_CHECK_NULL(pReturnType, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4247

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

4248

  pBlockIter = &pReader->status.blockIter;

×

UNCOV

4250

  *pReturnType = TSDB_READ_RETURN;

×

UNCOV

4252

  tsdbDebug("seq load data blocks from stt files %s", pReader->idStr);

×

UNCOV

4255

    code = doLoadSttBlockSequentially(pReader);

×

UNCOV

4256

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4258

    if (pResBlock->info.rows > 0) {

×

UNCOV

4259

      goto _end;

×

UNCOV

4263

    TSDB_CHECK_CONDITION(pReader->status.pTableIter == NULL, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);

×

UNCOV

4265

    code = initForFirstBlockInFile(pReader, pBlockIter);

×

UNCOV

4266

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4269

    if (pReader->status.loadFromFile == false) {

×

UNCOV

4270

      goto _end;

×

UNCOV

4273

    if (pReader->status.bProcMemPreFileset) {

×

UNCOV

4274

      code = buildFromPreFilesetBuffer(pReader);

×

UNCOV

4275

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4276

      if (pResBlock->info.rows > 0) {

×

UNCOV

4277

        pReader->status.processingMemPreFileSet = true;

×

UNCOV

4278

        goto _end;

×

UNCOV

4282

    if (pBlockIter->numOfBlocks > 0) {  // there are data blocks existed.

×

UNCOV

4283

      *pReturnType = TSDB_READ_CONTINUE;

×

UNCOV

4284

      goto _end;

×

UNCOV

4286

      code = resetTableListIndex(&pReader->status, pReader->idStr);

×

UNCOV

4287

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4291

_end:

×

UNCOV

4292

  if (code != TSDB_CODE_SUCCESS) {

×

4293

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4295

  return code;

×

UNCOV

4298

static int32_t buildBlockFromFiles(STsdbReader* pReader) {

×

UNCOV

4299

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

4300

  int32_t             lino = 0;

×

UNCOV

4301

  SDataBlockIter*     pBlockIter = NULL;

×

UNCOV

4302

  SSDataBlock*        pResBlock = NULL;

×

UNCOV

4303

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

4304

  SBlockData*         pBlockData = NULL;

×

UNCOV

4305

  const char*         id = NULL;

×

UNCOV

4306

  bool                asc = false;

×

UNCOV

4308

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4310

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

4312

  pBlockIter = &pReader->status.blockIter;

×

UNCOV

4313

  pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

4314

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

4315

  pBlockData = &pReader->status.fileBlockData;

×

UNCOV

4316

  id = pReader->idStr;

×

UNCOV

4318

  if (pBlockIter->numOfBlocks == 0) {

×

UNCOV

4320

    ERetrieveType type = 0;

×

UNCOV

4321

    code = doReadDataFromSttFiles(pReader, &type);

×

UNCOV

4322

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4323

    if (type == TSDB_READ_RETURN) {

×

UNCOV

4324

      goto _end;

×

4327

    code = doBuildDataBlock(pReader);

×

UNCOV

4328

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4329

    if (pResBlock->info.rows > 0) {

×

UNCOV

4330

      goto _end;

×

UNCOV

4335

    if (fileBlockPartiallyRead(pDumpInfo, asc)) {  // file data block is partially loaded

×

UNCOV

4336

      code = buildComposedDataBlock(pReader);

×

UNCOV

4337

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4340

      if (pDumpInfo->allDumped) {

×

UNCOV

4342

        bool hasNext = blockIteratorNext(&pReader->status.blockIter);

×

UNCOV

4343

        if (hasNext) {  // check for the next block in the block accessed order list

×

UNCOV

4344

          code = initBlockDumpInfo(pReader, pBlockIter);

×

UNCOV

4345

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4349

          if (pBlockData->uid != 0) {

×

UNCOV

4350

            tBlockDataClear(pBlockData);

×

UNCOV

4353

          tBlockDataReset(pBlockData);

×

UNCOV

4354

          code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), id);

×

UNCOV

4355

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4357

          code = resetTableListIndex(&pReader->status, id);

×

UNCOV

4358

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4360

          ERetrieveType type = 0;

×

UNCOV

4361

          code = doReadDataFromSttFiles(pReader, &type);

×

UNCOV

4362

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4363

          if (type == TSDB_READ_RETURN) {

×

UNCOV

4364

            break;

×

UNCOV

4369

      code = doBuildDataBlock(pReader);

×

UNCOV

4370

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4373

    if (pResBlock->info.rows > 0) {

×

UNCOV

4374

      break;

×

UNCOV

4378

_end:

×

UNCOV

4379

  if (code != TSDB_CODE_SUCCESS) {

×

4380

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4382

  return code;

×

UNCOV

4385

static void getTsdbByRetentions(SVnode* pVnode, SQueryTableDataCond* pCond, SRetention* retentions, const char* idStr,

×

UNCOV

4387

  if (pTsdb == NULL) {

×

4388

    return;

×

UNCOV

4391

  *pTsdb = NULL;

×

UNCOV

4392

  if (VND_IS_RSMA(pVnode) && !pCond->skipRollup) {

×

UNCOV

4393

    int8_t  level = 0;

×

UNCOV

4394

    int8_t  precision = pVnode->config.tsdbCfg.precision;

×

UNCOV

4395

    int64_t now = taosGetTimestamp(precision);

×

UNCOV

4396

    int64_t offset = tsQueryRsmaTolerance * ((precision == TSDB_TIME_PRECISION_MILLI)   ? 1L

×

UNCOV

4397

                                             : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000L

×

4398

                                                                                        : 1000000L);

×

UNCOV

4400

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

×

UNCOV

4401

      SRetention* pRetention = retentions + level;

×

UNCOV

4402

      if (pRetention->keep <= 0) {

×

4403

        if (level > 0) {

×

4404

          --level;

×

4406

        break;

×

UNCOV

4408

      if ((now - pRetention->keep) <= (pCond->twindows.skey + offset)) {

×

UNCOV

4409

        break;

×

UNCOV

4411

      ++level;

×

UNCOV

4414

    const char* str = (idStr != NULL) ? idStr : "";

×

UNCOV

4416

    if (level == TSDB_RETENTION_L0) {

×

UNCOV

4417

      *pLevel = TSDB_RETENTION_L0;

×

UNCOV

4418

      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L0, str);

×

UNCOV

4419

      *pTsdb = VND_RSMA0(pVnode);

×

UNCOV

4420

      return;

×

UNCOV

4421

    } else if (level == TSDB_RETENTION_L1) {

×

UNCOV

4422

      *pLevel = TSDB_RETENTION_L1;

×

UNCOV

4423

      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L1, str);

×

UNCOV

4424

      *pTsdb = VND_RSMA1(pVnode);

×

UNCOV

4425

      return;

×

UNCOV

4427

      *pLevel = TSDB_RETENTION_L2;

×

UNCOV

4428

      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L2, str);

×

UNCOV

4429

      *pTsdb = VND_RSMA2(pVnode);

×

UNCOV

4430

      return;

×

UNCOV

4434

  *pTsdb = VND_TSDB(pVnode);

×

UNCOV

4437

SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_t level) {

×

UNCOV

4438

  int64_t startVer = (pCond->startVersion == -1) ? 0 : pCond->startVersion;

×

UNCOV

4440

  int64_t endVer = 0;

×

UNCOV

4441

  if (pCond->endVersion == -1) {

×

UNCOV

4443

    endVer = pVnode->state.applied;

×

UNCOV

4445

    endVer = (pCond->endVersion > pVnode->state.applied) ? pVnode->state.applied : pCond->endVersion;

×

UNCOV

4448

  return (SVersionRange){.minVer = startVer, .maxVer = endVer};

×

UNCOV

4451

static int32_t reverseSearchStartPos(const SArray* pDelList, int32_t index, int64_t key, bool asc, int32_t* start) {

×

UNCOV

4452

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

4453

  int32_t lino = 0;

×

UNCOV

4454

  size_t  num = 0;

×

UNCOV

4456

  num = taosArrayGetSize(pDelList);

×

UNCOV

4457

  *start = index;

×

UNCOV

4459

  if (asc) {

×

UNCOV

4460

    if (*start >= num - 1) {

×

UNCOV

4461

      *start = num - 1;

×

UNCOV

4464

    TSDBKEY* p = taosArrayGet(pDelList, *start);

×

UNCOV

4465

    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4467

    while (p->ts >= key && *start > 0) {

×

UNCOV

4468

      *start -= 1;

×

UNCOV

4471

    if (index <= 0) {

×

4472

      *start = 0;

×

UNCOV

4475

    TSDBKEY* p = taosArrayGet(pDelList, *start);

×

UNCOV

4476

    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4478

    while (p->ts <= key && *start < num - 1) {

×

UNCOV

4479

      *start += 1;

×

UNCOV

4483

_end:

×

UNCOV

4484

  if (code != TSDB_CODE_SUCCESS) {

×

4485

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4487

  return code;

×

UNCOV

4490

int32_t hasBeenDropped(const SArray* pDelList, int32_t* index, int64_t key, int64_t ver, int32_t order,

×

UNCOV

4492

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

4493

  int32_t lino = 0;

×

UNCOV

4494

  size_t  num = 0;

×

UNCOV

4495

  int32_t step = 0;

×

UNCOV

4496

  bool    asc = false;

×

UNCOV

4498

  *dropped = false;

×

UNCOV

4500

  if (pDelList == NULL || (TARRAY_SIZE(pDelList) == 0)) {

×

4501

    goto _end;

×

UNCOV

4504

  num = taosArrayGetSize(pDelList);

×

UNCOV

4505

  asc = ASCENDING_TRAVERSE(order);

×

UNCOV

4506

  step = asc ? 1 : -1;

×

UNCOV

4508

  if (hasPk) {  // handle the case where duplicated timestamps existed.

×

UNCOV

4509

    code = reverseSearchStartPos(pDelList, *index, key, asc, index);

×

UNCOV

4510

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4513

  if (asc) {

×

UNCOV

4514

    if (*index >= num - 1) {

×

UNCOV

4515

      TSDBKEY* last = taosArrayGetLast(pDelList);

×

UNCOV

4516

      if (last == NULL) {

×

4517

        goto _end;

×

UNCOV

4520

      if (key > last->ts) {

×

UNCOV

4521

        goto _end;

×

UNCOV

4522

      } else if (key == last->ts) {

×

UNCOV

4523

        TSDBKEY* prev = taosArrayGet(pDelList, num - 2);

×

UNCOV

4524

        if (prev == NULL) {

×

4525

          goto _end;

×

UNCOV

4528

        *dropped = (prev->version >= ver && prev->version <= pVerRange->maxVer && prev->version >= pVerRange->minVer);

×

UNCOV

4531

      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);

×

UNCOV

4532

      TSDBKEY* pNext = taosArrayGet(pDelList, (*index) + 1);

×

UNCOV

4533

      if (pCurrent == NULL || pNext == NULL) {

×

4534

        goto _end;

×

UNCOV

4537

      if (key < pCurrent->ts) {

×

UNCOV

4538

        goto _end;

×

UNCOV

4541

      if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&

×

UNCOV

4542

          pVerRange->maxVer >= pCurrent->version) {

×

UNCOV

4543

        *dropped = true;

×

UNCOV

4544

        goto _end;

×

UNCOV

4547

      while (pNext->ts <= key && (*index) < num - 1) {

×

UNCOV

4548

        (*index) += 1;

×

UNCOV

4550

        if ((*index) < num - 1) {

×

UNCOV

4551

          pCurrent = taosArrayGet(pDelList, *index);

×

UNCOV

4552

          pNext = taosArrayGet(pDelList, (*index) + 1);

×

UNCOV

4553

          if (pCurrent == NULL || pNext == NULL) {

×

UNCOV

4558

          if (pCurrent->version == 0 && pNext->version > 0) {

×

UNCOV

4559

            continue;

×

UNCOV

4562

          if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&

×

UNCOV

4563

              pVerRange->maxVer >= pCurrent->version) {

×

UNCOV

4564

            *dropped = true;

×

UNCOV

4565

            break;

×

UNCOV

4571

    if (*index <= 0) {

×

4572

      TSDBKEY* pFirst = taosArrayGet(pDelList, 0);

×

4573

      if (pFirst == NULL) {

×

4574

        goto _end;

×

4577

      if (key < pFirst->ts) {

×

4578

        goto _end;

×

4579

      } else if (key == pFirst->ts) {

×

4580

        *dropped = pFirst->version >= ver;

×

4582

        tsdbError("unexpected error, key:%" PRId64 ", first:%" PRId64, key, pFirst->ts);

×

UNCOV

4585

      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);

×

UNCOV

4586

      TSDBKEY* pPrev = taosArrayGet(pDelList, (*index) - 1);

×

UNCOV

4587

      if (pCurrent == NULL || pPrev == NULL) {

×

4588

        goto _end;

×

UNCOV

4591

      if (key > pCurrent->ts) {

×

UNCOV

4592

        goto _end;

×

UNCOV

4595

      if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {

×

UNCOV

4596

        *dropped = true;

×

UNCOV

4597

        goto _end;

×

UNCOV

4600

      while (pPrev->ts >= key && (*index) > 1) {

×

UNCOV

4601

        (*index) += step;

×

UNCOV

4603

        if ((*index) >= 1) {

×

UNCOV

4604

          pCurrent = taosArrayGet(pDelList, *index);

×

UNCOV

4605

          pPrev = taosArrayGet(pDelList, (*index) - 1);

×

UNCOV

4606

          if (pCurrent == NULL || pPrev == NULL) {

×

UNCOV

4611

          if (pCurrent->version > 0 && pPrev->version == 0) {

×

UNCOV

4612

            continue;

×

UNCOV

4615

          if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {

×

UNCOV

4616

            *dropped = true;

×

UNCOV

4617

            break;

×

UNCOV

4624

_end:

×

UNCOV

4625

  if (code != TSDB_CODE_SUCCESS) {

×

4626

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4628

  return code;

×

UNCOV

4632

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

4633

  int32_t  lino = 0;

×

UNCOV

4634

  int32_t  order = 0;

×

UNCOV

4635

  TSDBROW* pRow = NULL;

×

UNCOV

4638

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4639

  TSDB_CHECK_NULL(pRes, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4641

  *pRes = NULL;

×

UNCOV

4643

  if (!pIter->hasVal) {

×

UNCOV

4644

    goto _end;

×

UNCOV

4647

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4648

  order = pReader->info.order;

×

UNCOV

4649

  pRow = tsdbTbDataIterGet(pIter->iter);

×

UNCOV

4651

  TSDBROW_INIT_KEY(pRow, key);

×

UNCOV

4652

  if (outOfTimeWindow(key.ts, &pReader->info.window)) {

×

4653

    pIter->hasVal = false;

×

4654

    goto _end;

×

UNCOV

4658

  if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {

×

UNCOV

4659

    if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {

×

UNCOV

4660

      *pRes = pRow;

×

UNCOV

4661

      goto _end;

×

UNCOV

4663

      bool dropped = false;

×

UNCOV

4664

      code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,

×

UNCOV

4665

                            pReader->suppInfo.numOfPks > 0, &dropped);

×

UNCOV

4666

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4667

      if (!dropped) {

×

UNCOV

4668

        *pRes = pRow;

×

UNCOV

4669

        goto _end;

×

4675

    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);

×

UNCOV

4676

    if (!pIter->hasVal) {

×

UNCOV

4677

      goto _end;

×

UNCOV

4680

    pRow = tsdbTbDataIterGet(pIter->iter);

×

UNCOV

4682

    TSDBROW_INIT_KEY(pRow, key);

×

UNCOV

4683

    if (outOfTimeWindow(key.ts, &pReader->info.window)) {

×

UNCOV

4684

      pIter->hasVal = false;

×

UNCOV

4685

      goto _end;

×

UNCOV

4688

    if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {

×

UNCOV

4689

      if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {

×

UNCOV

4690

        *pRes = pRow;

×

UNCOV

4691

        goto _end;

×

UNCOV

4693

        bool dropped = false;

×

UNCOV

4694

        code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,

×

UNCOV

4695

                              pReader->suppInfo.numOfPks > 0, &dropped);

×

UNCOV

4696

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4697

        if (!dropped) {

×

UNCOV

4698

          *pRes = pRow;

×

UNCOV

4699

          goto _end;

×

UNCOV

4705

_end:

×

UNCOV

4706

  if (code != TSDB_CODE_SUCCESS) {

×

4707

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4709

  return code;

×

UNCOV

4712

int32_t doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, SRowKey* pCurKey, SArray* pDelList, STsdbReader* pReader) {

×

UNCOV

4713

  int32_t     code = TSDB_CODE_SUCCESS;

×

UNCOV

4714

  int32_t     lino = 0;

×

UNCOV

4715

  SRowMerger* pMerger = NULL;

×

UNCOV

4717

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4718

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4720

  pMerger = &pReader->status.merger;

×

UNCOV

4722

  while (1) {

×

UNCOV

4723

    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);

×

UNCOV

4724

    if (!pIter->hasVal) {

×

UNCOV

4725

      break;

×

UNCOV

4729

    TSDBROW* pRow = NULL;

×

UNCOV

4730

    code = getValidMemRow(pIter, pDelList, pReader, &pRow);

×

UNCOV

4731

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4732

    if (pRow == NULL) {

×

UNCOV

4733

      break;

×

UNCOV

4737

    if (TSDBROW_TS(pRow) != pCurKey->ts) {

×

UNCOV

4738

      break;

×

UNCOV

4741

    if (pCurKey->numOfPKs > 0) {

×

UNCOV

4742

      SRowKey nextKey = {0};

×

UNCOV

4743

      tRowGetKeyEx(pRow, &nextKey);

×

UNCOV

4744

      if (pkCompEx(pCurKey, &nextKey) != 0) {

×

UNCOV

4745

        break;

×

UNCOV

4749

    STSchema* pTSchema = NULL;

×

UNCOV

4750

    if (pRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

4751

      pTSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, uid);

×

UNCOV

4752

      TSDB_CHECK_NULL(pTSchema, code, lino, _end, terrno);

×

UNCOV

4755

    code = tsdbRowMergerAdd(pMerger, pRow, pTSchema);

×

UNCOV

4756

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4759

_end:

×

UNCOV

4760

  if (code != TSDB_CODE_SUCCESS) {

×

4761

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4763

  return code;

×

UNCOV

4766

static int32_t doMergeRowsInFileBlockImpl(SBlockData* pBlockData, int32_t* rowIndex, SRowKey* pKey, SRowMerger* pMerger,

×

UNCOV

4768

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

4769

  int32_t lino = 0;

×

UNCOV

4771

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4772

  TSDB_CHECK_NULL(rowIndex, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4774

  while ((*rowIndex) < pBlockData->nRow && (*rowIndex) >= 0) {

×

UNCOV

4776

    tColRowGetKey(pBlockData, (*rowIndex), &cur);

×

UNCOV

4777

    if (pkCompEx(&cur, pKey) != 0) {

×

UNCOV

4778

      break;

×

4781

    if (pBlockData->aVersion[(*rowIndex)] > pVerRange->maxVer ||

×

UNCOV

4782

        pBlockData->aVersion[(*rowIndex)] < pVerRange->minVer) {

×

4783

      (*rowIndex) += step;

×

4784

      continue;

×

UNCOV

4787

    TSDBROW fRow = tsdbRowFromBlockData(pBlockData, (*rowIndex));

×

UNCOV

4788

    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);

×

UNCOV

4789

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4790

    (*rowIndex) += step;

×

UNCOV

4793

_end:

×

UNCOV

4794

  if (code != TSDB_CODE_SUCCESS) {

×

4795

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4797

  return code;

×

UNCOV

4805

static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,

×

UNCOV

4808

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

4809

  int32_t             lino = 0;

×

UNCOV

4810

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

4811

  SBlockData*         pBlockData = NULL;

×

UNCOV

4812

  bool                asc = false;

×

UNCOV

4813

  SVersionRange*      pVerRange = NULL;

×

UNCOV

4814

  bool                loadNeighbor = true;

×

UNCOV

4815

  int32_t             step = 0;

×

UNCOV

4817

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4818

  TSDB_CHECK_NULL(state, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4820

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

4821

  pBlockData = &pReader->status.fileBlockData;

×

UNCOV

4822

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

4823

  pVerRange = &pReader->info.verRange;

×

UNCOV

4824

  step = ASCENDING_TRAVERSE(pReader->info.order) ? 1 : -1;

×

UNCOV

4826

  *state = CHECK_FILEBLOCK_QUIT;

×

UNCOV

4827

  code = loadNeighborIfOverlap(pFBlock, pScanInfo, pReader, &loadNeighbor);

×

UNCOV

4828

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4830

  if (loadNeighbor) {

×

UNCOV

4831

    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pVerRange, step);

×

UNCOV

4832

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4833

    if ((pDumpInfo->rowIndex >= pDumpInfo->totalRows && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {

×

4834

      *state = CHECK_FILEBLOCK_CONT;

×

UNCOV

4838

_end:

×

UNCOV

4839

  if (code != TSDB_CODE_SUCCESS) {

×

4840

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4842

  return code;

×

UNCOV

4845

int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pScanInfo, SRowKey* pKey,

×

UNCOV

4847

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

4848

  int32_t             lino = 0;

×

UNCOV

4849

  SFileBlockDumpInfo* pDumpInfo = NULL;

×

UNCOV

4850

  SRowMerger*         pMerger = NULL;

×

UNCOV

4851

  bool                asc = false;

×

UNCOV

4852

  int32_t             step = 0;

×

UNCOV

4853

  SVersionRange*      pRange = NULL;

×

UNCOV

4855

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4856

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4858

  pDumpInfo = &pReader->status.fBlockDumpInfo;

×

UNCOV

4859

  pMerger = &pReader->status.merger;

×

UNCOV

4860

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

4861

  step = asc ? 1 : -1;

×

UNCOV

4862

  pRange = &pReader->info.verRange;

×

UNCOV

4864

  pDumpInfo->rowIndex += step;

×

UNCOV

4865

  if ((pDumpInfo->rowIndex <= pBlockData->nRow - 1 && asc) || (pDumpInfo->rowIndex >= 0 && !asc)) {

×

UNCOV

4866

    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pRange, step);

×

UNCOV

4867

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4871

  if ((pDumpInfo->rowIndex >= pBlockData->nRow && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {

×

4872

    while (1) {

×

UNCOV

4873

      SFileDataBlockInfo* pFileBlockInfo = NULL;

×

UNCOV

4874

      code = getCurrentBlockInfo(&pReader->status.blockIter, &pFileBlockInfo, pReader->idStr);

×

UNCOV

4875

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4877

      if (pFileBlockInfo == NULL) {

×

UNCOV

4878

        break;

×

UNCOV

4881

      CHECK_FILEBLOCK_STATE st = CHECK_FILEBLOCK_QUIT;

×

UNCOV

4882

      code = checkForNeighborFileBlock(pReader, pScanInfo, pFileBlockInfo, pMerger, pKey, &st);

×

UNCOV

4883

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4884

      if (st == CHECK_FILEBLOCK_QUIT) {

×

UNCOV

4885

        break;

×

UNCOV

4890

_end:

×

UNCOV

4891

  if (code != TSDB_CODE_SUCCESS) {

×

4892

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4894

  return code;

×

UNCOV

4897

int32_t doMergeRowsInSttBlock(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, SRowMerger* pMerger,

×

UNCOV

4899

  int32_t  code = TSDB_CODE_SUCCESS;

×

UNCOV

4900

  int32_t  lino = 0;

×

UNCOV

4901

  SRowKey* pRowKey = NULL;

×

UNCOV

4902

  SRowKey* pNextKey = NULL;

×

UNCOV

4904

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4906

  pRowKey = &pScanInfo->lastProcKey;

×

UNCOV

4908

  while (1) {

×

UNCOV

4909

    code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pkSrcSlot, pVerRange);

×

UNCOV

4910

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4911

    if (!hasDataInSttBlock(pScanInfo)) {

×

UNCOV

4912

      break;

×

UNCOV

4915

    pNextKey = getCurrentKeyInSttBlock(pSttBlockReader);

×

UNCOV

4917

    int32_t ret = pkCompEx(pRowKey, pNextKey);

×

UNCOV

4918

    if (ret == 0) {

×

UNCOV

4919

      TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);

×

UNCOV

4920

      code = tsdbRowMergerAdd(pMerger, pRow1, NULL);

×

UNCOV

4921

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4923

      tsdbTrace("uid:%" PRIu64 " last del index:%d, del range:%d, lastKeyInStt:%" PRId64 ", %s", pScanInfo->uid,

×

UNCOV

4926

      break;

×

UNCOV

4930

_end:

×

UNCOV

4931

  if (code != TSDB_CODE_SUCCESS) {

×

4932

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

4934

  return code;

×

UNCOV

4937

int32_t doMergeMemTableMultiRows(TSDBROW* pRow, SRowKey* pKey, uint64_t uid, SIterInfo* pIter, SArray* pDelList,

×

UNCOV

4939

  int32_t     code = TSDB_CODE_SUCCESS;

×

UNCOV

4940

  int32_t     lino = 0;

×

UNCOV

4941

  SRowMerger* pMerger = NULL;

×

UNCOV

4942

  TSDBROW*    pNextRow = NULL;

×

UNCOV

4943

  STSchema*   pTSchema = NULL;

×

UNCOV

4944

  STSchema*   pTSchema1 = NULL;

×

UNCOV

4947

  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4948

  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4949

  TSDB_CHECK_NULL(pResRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4950

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4951

  TSDB_CHECK_NULL(freeTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

4953

  pMerger = &pReader->status.merger;

×

UNCOV

4954

  current = *pRow;

×

UNCOV

4957

    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);

×

UNCOV

4959

    if (!pIter->hasVal) {

×

UNCOV

4960

      *pResRow = *pRow;

×

UNCOV

4961

      *freeTSRow = false;

×

UNCOV

4962

      goto _end;

×

UNCOV

4964

      code = getValidMemRow(pIter, pDelList, pReader, &pNextRow);

×

UNCOV

4965

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4966

      if (pNextRow == NULL) {

×

UNCOV

4967

        *pResRow = current;

×

UNCOV

4968

        *freeTSRow = false;

×

UNCOV

4969

        goto _end;

×

UNCOV

4972

      if (TSDBROW_TS(&current) != TSDBROW_TS(pNextRow)) {

×

UNCOV

4973

        *pResRow = current;

×

UNCOV

4974

        *freeTSRow = false;

×

UNCOV

4975

        goto _end;

×

UNCOV

4978

      if (pKey->numOfPKs > 0) {

×

UNCOV

4979

        SRowKey nextRowKey = {0};

×

UNCOV

4980

        tRowGetKeyEx(pNextRow, &nextRowKey);

×

UNCOV

4981

        if (pkCompEx(pKey, &nextRowKey) != 0) {

×

UNCOV

4982

          *pResRow = current;

×

UNCOV

4983

          *freeTSRow = false;

×

UNCOV

4984

          goto _end;

×

UNCOV

4991

  if (current.type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory

×

UNCOV

4992

    pTSchema = doGetSchemaForTSRow(current.pTSRow->sver, pReader, uid);

×

UNCOV

4993

    TSDB_CHECK_NULL(pTSchema, code, lino, _end, terrno);

×

UNCOV

4996

  code = tsdbRowMergerAdd(pMerger, &current, pTSchema);

×

UNCOV

4997

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

4999

  if (pNextRow->type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory

×

UNCOV

5000

    pTSchema1 = doGetSchemaForTSRow(pNextRow->pTSRow->sver, pReader, uid);

×

UNCOV

5001

    TSDB_CHECK_NULL(pTSchema1, code, lino, _end, terrno);

×

UNCOV

5004

  code = tsdbRowMergerAdd(pMerger, pNextRow, pTSchema1);

×

UNCOV

5005

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5007

  code = doMergeRowsInBuf(pIter, uid, pKey, pDelList, pReader);

×

UNCOV

5008

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5010

  code = tsdbRowMergerGetRow(pMerger, &pResRow->pTSRow);

×

UNCOV

5011

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5013

  pResRow->type = TSDBROW_ROW_FMT;

×

UNCOV

5014

  tsdbRowMergerClear(pMerger);

×

UNCOV

5015

  *freeTSRow = true;

×

UNCOV

5017

_end:

×

UNCOV

5018

  if (code != TSDB_CODE_SUCCESS) {

×

5019

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5021

  return code;

×

UNCOV

5024

int32_t doMergeMemIMemRows(TSDBROW* pRow, SRowKey* pRowKey, TSDBROW* piRow, SRowKey* piRowKey,

×

UNCOV

5026

  int32_t     code = TSDB_CODE_SUCCESS;

×

UNCOV

5027

  int32_t     lino = 0;

×

UNCOV

5028

  SRowMerger* pMerger = NULL;

×

UNCOV

5029

  STSchema*   pSchema = NULL;

×

UNCOV

5030

  STSchema*   piSchema = NULL;

×

UNCOV

5032

  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5033

  TSDB_CHECK_NULL(piRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5034

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5035

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5037

  pMerger = &pReader->status.merger;

×

UNCOV

5039

  if (pRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

5040

    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);

×

UNCOV

5041

    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

5044

  if (piRow->type == TSDBROW_ROW_FMT) {

×

UNCOV

5045

    piSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(piRow), pReader, pBlockScanInfo->uid);

×

UNCOV

5046

    TSDB_CHECK_NULL(piSchema, code, lino, _end, terrno);

×

UNCOV

5049

  if (ASCENDING_TRAVERSE(pReader->info.order)) {  // ascending order imem --> mem

×

UNCOV

5050

    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);

×

UNCOV

5051

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5053

    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);

×

UNCOV

5054

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5056

    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);

×

UNCOV

5057

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5059

    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);

×

UNCOV

5060

    TSDB_CHECK_CODE(code, lino, _end);

×

5062

    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);

×

5063

    TSDB_CHECK_CODE(code, lino, _end);

×

5065

    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);

×

5066

    TSDB_CHECK_CODE(code, lino, _end);

×

5068

    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);

×

5069

    TSDB_CHECK_CODE(code, lino, _end);

×

5071

    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);

×

5072

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5075

  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pRowKey);

×

UNCOV

5077

  code = tsdbRowMergerGetRow(pMerger, pTSRow);

×

UNCOV

5078

  tsdbRowMergerClear(pMerger);

×

UNCOV

5079

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5081

_end:

×

UNCOV

5082

  if (code != TSDB_CODE_SUCCESS) {

×

5083

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5085

  return code;

×

UNCOV

5088

static int32_t tsdbGetNextRowInMem(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, TSDBROW* pResRow,

×

UNCOV

5090

  int32_t    code = TSDB_CODE_SUCCESS;

×

UNCOV

5091

  int32_t    lino = 0;

×

UNCOV

5092

  TSDBROW*   pRow = NULL;

×

UNCOV

5093

  TSDBROW*   piRow = NULL;

×

UNCOV

5094

  SArray*    pDelList = NULL;

×

UNCOV

5095

  uint64_t   uid = 0;

×

UNCOV

5096

  SIterInfo* piter = NULL;

×

UNCOV

5097

  SIterInfo* piiter = NULL;

×

UNCOV

5098

  SRowKey    rowKey = {0};

×

UNCOV

5099

  SRowKey    irowKey = {0};

×

UNCOV

5100

  bool       asc = false;

×

UNCOV

5102

  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5103

  TSDB_CHECK_NULL(pResRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5104

  TSDB_CHECK_NULL(freeTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5106

  code = getValidMemRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader, &pRow);

×

UNCOV

5107

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5108

  code = getValidMemRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader, &piRow);

×

UNCOV

5109

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5111

  pDelList = pBlockScanInfo->delSkyline;

×

UNCOV

5112

  uid = pBlockScanInfo->uid;

×

UNCOV

5113

  piter = &pBlockScanInfo->iter;

×

UNCOV

5114

  piiter = &pBlockScanInfo->iiter;

×

UNCOV

5117

  asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

5118

  if (piter->hasVal) {

×

UNCOV

5119

    tRowGetKeyEx(pRow, &rowKey);

×

UNCOV

5120

    if ((rowKey.ts >= endKey && asc) || (rowKey.ts <= endKey && !asc)) {

×

UNCOV

5121

      pRow = NULL;

×

UNCOV

5125

  if (piiter->hasVal) {

×

UNCOV

5126

    tRowGetKeyEx(piRow, &irowKey);

×

UNCOV

5127

    if ((irowKey.ts >= endKey && asc) || (irowKey.ts <= endKey && !asc)) {

×

UNCOV

5128

      piRow = NULL;

×

UNCOV

5132

  if (pRow != NULL && piRow != NULL) {

×

UNCOV

5133

    if (rowKey.numOfPKs == 0) {

×

UNCOV

5134

      if ((rowKey.ts > irowKey.ts && asc) || (rowKey.ts < irowKey.ts && (!asc))) {  // ik.ts < k.ts

×

UNCOV

5135

        code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5136

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5137

      } else if ((rowKey.ts < irowKey.ts && asc) || (rowKey.ts > irowKey.ts && (!asc))) {

×

UNCOV

5138

        code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5139

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5141

        pResRow->type = TSDBROW_ROW_FMT;

×

UNCOV

5142

        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);

×

UNCOV

5143

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5144

        *freeTSRow = true;

×

UNCOV

5147

      int32_t ret = pkCompEx(&rowKey, &irowKey);

×

UNCOV

5148

      if (ret != 0) {

×

UNCOV

5149

        if ((ret > 0 && asc) || (ret < 0 && (!asc))) {  // ik.ts < k.ts

×

UNCOV

5150

          code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5151

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5152

        } else if ((ret < 0 && asc) || (ret > 0 && (!asc))) {

×

UNCOV

5153

          code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5154

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5157

        pResRow->type = TSDBROW_ROW_FMT;

×

UNCOV

5158

        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);

×

5159

        TSDB_CHECK_CODE(code, lino, _end);

×

5160

        *freeTSRow = true;

×

UNCOV

5163

  } else if (piter->hasVal && pRow != NULL) {

×

UNCOV

5164

    code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5165

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5166

  } else if (piiter->hasVal && piRow != NULL) {

×

UNCOV

5167

    code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);

×

UNCOV

5168

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5171

_end:

×

UNCOV

5172

  if (code != TSDB_CODE_SUCCESS) {

×

5173

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5175

  return code;

×

UNCOV

5178

int32_t doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, SRow* pTSRow, STableBlockScanInfo* pScanInfo) {

×

UNCOV

5179

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

5180

  int32_t             lino = 0;

×

UNCOV

5181

  int32_t             outputRowIndex = 0;

×

UNCOV

5182

  int64_t             uid = 0;

×

UNCOV

5183

  SBlockLoadSuppInfo* pSupInfo = NULL;

×

UNCOV

5184

  STSchema*           pSchema = NULL;

×

UNCOV

5185

  SColVal             colVal = {0};

×

UNCOV

5186

  int32_t             i = 0, j = 0;

×

UNCOV

5188

  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5189

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5190

  TSDB_CHECK_NULL(pTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5191

  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5193

  outputRowIndex = pBlock->info.rows;

×

UNCOV

5194

  uid = pScanInfo->uid;

×

UNCOV

5196

  pSupInfo = &pReader->suppInfo;

×

UNCOV

5197

  pSchema = doGetSchemaForTSRow(pTSRow->sver, pReader, uid);

×

UNCOV

5198

  TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);

×

UNCOV

5200

  if (pSupInfo->colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {

×

UNCOV

5201

    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

5202

    TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5204

    ((int64_t*)pColData->pData)[outputRowIndex] = pTSRow->ts;

×

UNCOV

5205

    i += 1;

×

UNCOV

5208

  while (i < pSupInfo->numOfCols && j < pSchema->numOfCols) {

×

UNCOV

5209

    col_id_t colId = pSupInfo->colId[i];

×

UNCOV

5211

    if (colId == pSchema->columns[j].colId) {

×

UNCOV

5212

      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

5213

      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5215

      code = tRowGet(pTSRow, pSchema, j, &colVal);

×

UNCOV

5216

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5218

      code = doCopyColVal(pColInfoData, outputRowIndex, i, &colVal, pSupInfo);

×

UNCOV

5219

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5220

      i += 1;

×

UNCOV

5221

      j += 1;

×

UNCOV

5222

    } else if (colId < pSchema->columns[j].colId) {

×

5223

      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);

×

5224

      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

5226

      colDataSetNULL(pColInfoData, outputRowIndex);

×

5227

      i += 1;

×

UNCOV

5228

    } else if (colId > pSchema->columns[j].colId) {

×

UNCOV

5229

      j += 1;

×

UNCOV

5234

  while (i < pSupInfo->numOfCols) {

×

UNCOV

5235

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

5236

    TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5238

    colDataSetNULL(pColInfoData, outputRowIndex);

×

UNCOV

5239

    i += 1;

×

UNCOV

5242

  pBlock->info.dataLoad = 1;

×

UNCOV

5243

  pBlock->info.rows += 1;

×

UNCOV

5245

_end:

×

UNCOV

5246

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

5247

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5249

  return code;

×

UNCOV

5252

int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, SBlockData* pBlockData,

×

UNCOV

5254

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

5255

  int32_t             lino = 0;

×

UNCOV

5256

  int32_t             i = 0, j = 0;

×

UNCOV

5257

  int32_t             outputRowIndex = 0;

×

UNCOV

5258

  SBlockLoadSuppInfo* pSupInfo = NULL;

×

UNCOV

5259

  SColVal             cv = {0};

×

UNCOV

5260

  int32_t             numOfInputCols = 0;

×

UNCOV

5261

  int32_t             numOfOutputCols = 0;

×

UNCOV

5263

  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5264

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5265

  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5267

  outputRowIndex = pResBlock->info.rows;

×

UNCOV

5269

  pSupInfo = &pReader->suppInfo;

×

UNCOV

5270

  ((int64_t*)pReader->status.pPrimaryTsCol->pData)[outputRowIndex] = pBlockData->aTSKEY[rowIndex];

×

UNCOV

5271

  i += 1;

×

UNCOV

5273

  numOfInputCols = pBlockData->nColData;

×

UNCOV

5274

  numOfOutputCols = pSupInfo->numOfCols;

×

UNCOV

5276

  while (i < numOfOutputCols && j < numOfInputCols) {

×

UNCOV

5277

    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, j);

×

UNCOV

5278

    if (pData->cid < pSupInfo->colId[i]) {

×

UNCOV

5279

      j += 1;

×

UNCOV

5280

      continue;

×

UNCOV

5283

    SColumnInfoData* pCol = TARRAY_GET_ELEM(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

5284

    if (pData->cid == pSupInfo->colId[i]) {

×

UNCOV

5285

      tColDataGetValue(pData, rowIndex, &cv);

×

UNCOV

5286

      code = doCopyColVal(pCol, outputRowIndex, i, &cv, pSupInfo);

×

UNCOV

5287

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5288

      j += 1;

×

5289

    } else if (pData->cid > pCol->info.colId) {

×

5291

      colDataSetNULL(pCol, outputRowIndex);

×

UNCOV

5294

    i += 1;

×

UNCOV

5297

  while (i < numOfOutputCols) {

×

UNCOV

5298

    SColumnInfoData* pCol = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);

×

UNCOV

5299

    TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5301

    colDataSetNULL(pCol, outputRowIndex);

×

UNCOV

5302

    i += 1;

×

UNCOV

5305

  pResBlock->info.dataLoad = 1;

×

UNCOV

5306

  pResBlock->info.rows += 1;

×

UNCOV

5308

_end:

×

UNCOV

5309

  if (code != TSDB_CODE_SUCCESS) {

×

5310

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5312

  return code;

×

UNCOV

5315

int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity,

×

UNCOV

5317

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

5318

  int32_t      lino = 0;

×

UNCOV

5319

  SSDataBlock* pBlock = NULL;

×

UNCOV

5321

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5323

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

5325

  do {

×

UNCOV

5326

    TSDBROW row = {.type = -1};

×

UNCOV

5327

    bool    freeTSRow = false;

×

UNCOV

5328

    code = tsdbGetNextRowInMem(pBlockScanInfo, pReader, &row, endKey, &freeTSRow);

×

UNCOV

5329

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5331

    if (row.type == -1) {

×

UNCOV

5332

      break;

×

UNCOV

5335

    if (row.type == TSDBROW_ROW_FMT) {

×

UNCOV

5336

      code = doAppendRowFromTSRow(pBlock, pReader, row.pTSRow, pBlockScanInfo);

×

UNCOV

5337

      if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

5338

        if (freeTSRow) {

×

5339

          taosMemoryFreeClear(row.pTSRow);

×

UNCOV

5341

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5343

      pBlockScanInfo->lastProcKey.ts = row.pTSRow->ts;

×

UNCOV

5344

      pBlockScanInfo->lastProcKey.numOfPKs = row.pTSRow->numOfPKs;

×

UNCOV

5345

      if (row.pTSRow->numOfPKs > 0) {

×

UNCOV

5346

        code = tRowGetPrimaryKeyDeepCopy(row.pTSRow, &pBlockScanInfo->lastProcKey);

×

UNCOV

5347

        if (code != TSDB_CODE_SUCCESS) {

×

5348

          if (freeTSRow) {

×

5349

            taosMemoryFreeClear(row.pTSRow);

×

5351

          TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5355

      if (freeTSRow) {

×

UNCOV

5356

        taosMemoryFreeClear(row.pTSRow);

×

UNCOV

5359

      code = doAppendRowFromFileBlock(pBlock, pReader, row.pBlockData, row.iRow);

×

UNCOV

5360

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5362

      tColRowGetKeyDeepCopy(row.pBlockData, row.iRow, pReader->suppInfo.pkSrcSlot, &pBlockScanInfo->lastProcKey);

×

UNCOV

5366

    if (!(pBlockScanInfo->iter.hasVal || pBlockScanInfo->iiter.hasVal)) {

×

UNCOV

5367

      break;

×

UNCOV

5370

    if (pBlock->info.rows >= capacity) {

×

UNCOV

5371

      break;

×

UNCOV

5375

_end:

×

UNCOV

5376

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

5377

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5379

  return code;

×

UNCOV

5383

int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t num) {

×

UNCOV

5384

  int32_t               code = TSDB_CODE_SUCCESS;

×

UNCOV

5385

  int32_t               lino = 0;

×

UNCOV

5386

  int32_t               size = 0;

×

UNCOV

5387

  STableBlockScanInfo** p = NULL;

×

UNCOV

5388

  STableUidList*        pUidList = NULL;

×

UNCOV

5389

  int32_t               iter = 0;

×

UNCOV

5390

  bool                  acquired = false;

×

UNCOV

5392

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5394

  size = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

5396

  code = tsdbAcquireReader(pReader);

×

UNCOV

5397

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5398

  acquired = true;

×

UNCOV

5400

  while ((p = tSimpleHashIterate(pReader->status.pTableMap, p, &iter)) != NULL) {

×

UNCOV

5401

    clearBlockScanInfo(*p);

×

UNCOV

5404

  tSimpleHashClear(pReader->status.pTableMap);

×

UNCOV

5406

  if (size < num) {

×

UNCOV

5407

    code = ensureBlockScanInfoBuf(&pReader->blockInfoBuf, num);

×

UNCOV

5408

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5410

    char* p1 = taosMemoryRealloc(pReader->status.uidList.tableUidList, sizeof(uint64_t) * num);

×

UNCOV

5411

    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);

×

UNCOV

5413

    pReader->status.uidList.tableUidList = (uint64_t*)p1;

×

UNCOV

5416

  pUidList = &pReader->status.uidList;

×

UNCOV

5417

  pUidList->currentIndex = 0;

×

UNCOV

5419

  STableKeyInfo* pList = (STableKeyInfo*)pTableList;

×

UNCOV

5420

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

×

UNCOV

5421

    pUidList->tableUidList[i] = pList[i].uid;

×

UNCOV

5423

    STableBlockScanInfo* pInfo = NULL;

×

UNCOV

5424

    code = getPosInBlockInfoBuf(&pReader->blockInfoBuf, i, &pInfo);

×

UNCOV

5425

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5427

    code = initTableBlockScanInfo(pInfo, pList[i].uid, pReader->status.pTableMap, pReader);

×

UNCOV

5428

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5431

_end:

×

UNCOV

5432

  if (code != TSDB_CODE_SUCCESS) {

×

5433

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5435

  if (acquired) {

×

UNCOV

5436

    (void)tsdbReleaseReader(pReader);

×

UNCOV

5438

  return code;

×

5441

uint64_t tsdbGetReaderMaxVersion2(STsdbReader* pReader) { return pReader->info.verRange.maxVer; }

×

UNCOV

5443

static int32_t doOpenReaderImpl(STsdbReader* pReader) {

×

UNCOV

5444

  int32_t         code = TSDB_CODE_SUCCESS;

×

UNCOV

5445

  int32_t         lino = 0;

×

UNCOV

5446

  SReaderStatus*  pStatus = NULL;

×

UNCOV

5447

  SDataBlockIter* pBlockIter = NULL;

×

UNCOV

5449

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5451

  pStatus = &pReader->status;

×

UNCOV

5452

  pBlockIter = &pStatus->blockIter;

×

UNCOV

5454

  if (pReader->bFilesetDelimited) {

×

UNCOV

5455

    getMemTableTimeRange(pReader, &pReader->status.memTableMaxKey, &pReader->status.memTableMinKey);

×

UNCOV

5456

    pReader->status.bProcMemFirstFileset = true;

×

UNCOV

5459

  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);

×

UNCOV

5460

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5462

  code = resetDataBlockIterator(&pStatus->blockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo),

×

UNCOV

5463

                                pReader->idStr);

×

UNCOV

5464

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5466

  if (pStatus->fileIter.numOfFiles == 0) {

×

UNCOV

5467

    pStatus->loadFromFile = false;

×

UNCOV

5469

    code = initForFirstBlockInFile(pReader, pBlockIter);

×

UNCOV

5472

  if (!pStatus->loadFromFile) {

×

UNCOV

5473

    code = resetTableListIndex(pStatus, pReader->idStr);

×

UNCOV

5474

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5477

_end:

×

UNCOV

5478

  if (code != TSDB_CODE_SUCCESS) {

×

5479

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5481

  return code;

×

UNCOV

5484

static void freeSchemaFunc(void* param) {

×

UNCOV

5485

  void** p = (void**)param;

×

UNCOV

5486

  taosMemoryFreeClear(*p);

×

UNCOV

5487

×

UNCOV

5489

static void clearSharedPtr(STsdbReader* p) {

×

UNCOV

5490

  if (p) {

×

UNCOV

5491

    p->status.pTableMap = NULL;

×

UNCOV

5492

    p->status.uidList.tableUidList = NULL;

×

UNCOV

5493

    p->info.pSchema = NULL;

×

UNCOV

5494

    p->pReadSnap = NULL;

×

UNCOV

5495

    p->pSchemaMap = NULL;

×

UNCOV

5497

×

UNCOV

5499

static int32_t setSharedPtr(STsdbReader* pDst, const STsdbReader* pSrc) {

×

UNCOV

5500

  pDst->status.pTableMap = pSrc->status.pTableMap;

×

UNCOV

5501

  pDst->status.uidList = pSrc->status.uidList;

×

UNCOV

5502

  pDst->info.pSchema = pSrc->info.pSchema;

×

UNCOV

5503

  pDst->pSchemaMap = pSrc->pSchemaMap;

×

UNCOV

5504

  pDst->pReadSnap = pSrc->pReadSnap;

×

UNCOV

5505

  pDst->pReadSnap->pfSetArray = pSrc->pReadSnap->pfSetArray;

×

UNCOV

5507

  if (pDst->info.pSchema) {

×

UNCOV

5508

    return tsdbRowMergerInit(&pDst->status.merger, pDst->info.pSchema);

×

5511

  return TSDB_CODE_SUCCESS;

×

UNCOV

5515

int32_t tsdbReaderOpen2(void* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,

×

UNCOV

5517

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

5518

  int32_t      lino = 0;

×

UNCOV

5519

  STimeWindow  window = {0};

×

UNCOV

5520

  SVnodeCfg*   pConf = NULL;

×

UNCOV

5521

  STsdbReader* pReader = NULL;

×

UNCOV

5522

  int32_t      capacity = 0;

×

UNCOV

5524

  window = pCond->twindows;

×

UNCOV

5525

  pConf = &(((SVnode*)pVnode)->config);

×

UNCOV

5527

  capacity = pConf->tsdbCfg.maxRows;

×

UNCOV

5528

  if (pResBlock != NULL) {

×

UNCOV

5529

    code = blockDataEnsureCapacity(pResBlock, capacity);

×

UNCOV

5530

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5533

  code = tsdbReaderCreate(pVnode, pCond, ppReader, capacity, pResBlock, idstr);

×

UNCOV

5534

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5537

  pReader = *ppReader;

×

UNCOV

5538

  if (isEmptyQueryTimeWindow(&pReader->info.window) && pCond->type == TIMEWINDOW_RANGE_CONTAINED) {

×

UNCOV

5539

    tsdbDebug("%p query window not overlaps with the data set, no result returned, %s", pReader, pReader->idStr);

×

UNCOV

5540

    goto _end;

×

UNCOV

5543

  if (pCond->type == TIMEWINDOW_RANGE_EXTERNAL) {

×

UNCOV

5545

    int32_t order = pCond->order;

×

UNCOV

5546

    if (order == TSDB_ORDER_ASC) {

×

UNCOV

5547

      pCond->twindows = pCond->extTwindows[0];

×

UNCOV

5548

      pCond->order = TSDB_ORDER_DESC;

×

5550

      pCond->twindows = pCond->extTwindows[1];

×

5551

      pCond->order = TSDB_ORDER_ASC;

×

UNCOV

5555

    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[0], 1, pResBlock, idstr);

×

UNCOV

5556

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5558

    if (order == TSDB_ORDER_ASC) {

×

UNCOV

5559

      pCond->twindows = pCond->extTwindows[1];

×

5561

      pCond->twindows = pCond->extTwindows[0];

×

UNCOV

5563

    pCond->order = order;

×

UNCOV

5565

    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[1], 1, pResBlock, idstr);

×

UNCOV

5566

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5572

  if (pCond->suid != 0) {

×

UNCOV

5573

    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1, &pReader->info.pSchema);

×

UNCOV

5574

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5575

    if (pReader->info.pSchema == NULL) {

×

UNCOV

5576

      tsdbWarn("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->info.suid, pReader->idStr);

×

UNCOV

5578

  } else if (numOfTables > 0) {

×

UNCOV

5579

    STableKeyInfo* pKey = pTableList;

×

UNCOV

5580

    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1, &pReader->info.pSchema);

×

UNCOV

5581

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5582

    if (pReader->info.pSchema == NULL) {

×

UNCOV

5583

      tsdbWarn("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr);

×

UNCOV

5587

  if (pReader->info.pSchema != NULL) {

×

UNCOV

5588

    code = tsdbRowMergerInit(&pReader->status.merger, pReader->info.pSchema);

×

UNCOV

5589

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5592

  pReader->pSchemaMap = tSimpleHashInit(8, taosFastHash);

×

UNCOV

5593

  if (pReader->pSchemaMap == NULL) {

×

5594

    tsdbError("failed init schema hash for reader %s", pReader->idStr);

×

5595

    TSDB_CHECK_NULL(pReader->pSchemaMap, code, lino, _end, terrno);

×

UNCOV

5598

  tSimpleHashSetFreeFp(pReader->pSchemaMap, freeSchemaFunc);

×

UNCOV

5599

  if (pReader->info.pSchema != NULL) {

×

UNCOV

5600

    code = updateBlockSMAInfo(pReader->info.pSchema, &pReader->suppInfo);

×

UNCOV

5601

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5604

  STsdbReader* p = (pReader->innerReader[0] != NULL) ? pReader->innerReader[0] : pReader;

×

UNCOV

5606

  code = createDataBlockScanInfo(p, &pReader->blockInfoBuf, pTableList, &pReader->status.uidList, numOfTables,

×

UNCOV

5608

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5610

  pReader->status.pLDataIterArray = taosArrayInit(4, POINTER_BYTES);

×

UNCOV

5611

  TSDB_CHECK_NULL(pReader->status.pLDataIterArray, code, lino, _end, terrno);

×

UNCOV

5613

  pReader->flag = READER_STATUS_SUSPEND;

×

UNCOV

5614

  pReader->info.execMode = pCond->notLoadData ? READER_EXEC_ROWS : READER_EXEC_DATA;

×

UNCOV

5616

  pReader->pIgnoreTables = pIgnoreTables;

×

UNCOV

5617

  tsdbDebug("%p total numOfTable:%d, window:%" PRId64 " - %" PRId64 ", verRange:%" PRId64 " - %" PRId64

×

UNCOV

5622

_end:

×

UNCOV

5623

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

5624

    tsdbError("%s failed at line %d since %s, %s", __func__, lino, tstrerror(code), idstr);

×

UNCOV

5625

    tsdbReaderClose2(*ppReader);

×

UNCOV

5626

    *ppReader = NULL;  // reset the pointer value.

×

UNCOV

5628

  return code;

×

UNCOV

5631

void tsdbReaderClose2(STsdbReader* pReader) {

×

UNCOV

5632

  if (pReader == NULL) {

×

UNCOV

5633

    return;

×

UNCOV

5636

  int32_t code = tsdbAcquireReader(pReader);

×

UNCOV

5637

  if (code) {

×

5638

    return;

×

UNCOV

5642

    if (pReader->innerReader[0] != NULL || pReader->innerReader[1] != NULL) {

×

UNCOV

5643

      STsdbReader* p = pReader->innerReader[0];

×

UNCOV

5644

      clearSharedPtr(p);

×

UNCOV

5646

      p = pReader->innerReader[1];

×

UNCOV

5647

      clearSharedPtr(p);

×

UNCOV

5649

      tsdbReaderClose2(pReader->innerReader[0]);

×

UNCOV

5650

      tsdbReaderClose2(pReader->innerReader[1]);

×

UNCOV

5654

  SBlockLoadSuppInfo* pSupInfo = &pReader->suppInfo;

×

UNCOV

5655

  TARRAY2_DESTROY(&pSupInfo->colAggArray, NULL);

×

UNCOV

5657

  if (pSupInfo->buildBuf) {

×

UNCOV

5658

    for (int32_t i = 0; i < pSupInfo->numOfCols; ++i) {

×

UNCOV

5659

      if (pSupInfo->buildBuf[i] != NULL) {

×

UNCOV

5660

        taosMemoryFreeClear(pSupInfo->buildBuf[i]);

×

UNCOV

5665

  if (pReader->resBlockInfo.freeBlock) {

×

UNCOV

5666

    blockDataDestroy(pReader->resBlockInfo.pResBlock);

×

UNCOV

5667

    pReader->resBlockInfo.pResBlock = NULL;

×

UNCOV

5670

  taosMemoryFree(pSupInfo->colId);

×

UNCOV

5671

  tBlockDataDestroy(&pReader->status.fileBlockData);

×

UNCOV

5672

  cleanupDataBlockIterator(&pReader->status.blockIter, shouldFreePkBuf(&pReader->suppInfo));

×

UNCOV

5674

  size_t numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

5675

  if (pReader->status.pTableMap != NULL) {

×

UNCOV

5676

    destroyAllBlockScanInfo(&pReader->status.pTableMap);

×

UNCOV

5678

  clearBlockScanInfoBuf(&pReader->blockInfoBuf);

×

UNCOV

5680

  if (pReader->pFileReader != NULL) {

×

UNCOV

5681

    tsdbDataFileReaderClose(&pReader->pFileReader);

×

UNCOV

5684

  SReadCostSummary* pCost = &pReader->cost;

×

UNCOV

5685

  SFilesetIter*     pFilesetIter = &pReader->status.fileIter;

×

UNCOV

5686

  if (pFilesetIter->pSttBlockReader != NULL) {

×

UNCOV

5687

    SSttBlockReader* pSttBlockReader = pFilesetIter->pSttBlockReader;

×

UNCOV

5688

    tMergeTreeClose(&pSttBlockReader->mergeTree);

×

UNCOV

5690

    clearRowKey(&pSttBlockReader->currentKey);

×

UNCOV

5691

    taosMemoryFree(pSttBlockReader);

×

UNCOV

5694

  destroySttBlockReader(pReader->status.pLDataIterArray, &pCost->sttCost);

×

UNCOV

5695

  pReader->status.pLDataIterArray = NULL;

×

UNCOV

5696

  taosMemoryFreeClear(pReader->status.uidList.tableUidList);

×

UNCOV

5698

  tsdbTrace("tsdb/reader-close: %p, untake snapshot", pReader);

×

UNCOV

5699

  void* p = pReader->pReadSnap;

×

UNCOV

5700

  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {

×

UNCOV

5701

    tsdbUntakeReadSnap2(pReader, p, true);

×

UNCOV

5702

    pReader->pReadSnap = NULL;

×

UNCOV

5705

  (void) tsem_destroy(&pReader->resumeAfterSuspend);

×

UNCOV

5706

  (void) tsdbReleaseReader(pReader);

×

UNCOV

5707

  (void) tsdbUninitReaderLock(pReader);

×

UNCOV

5709

  tsdbDebug(

×

UNCOV

5723

  taosMemoryFree(pReader->idStr);

×

UNCOV

5725

  tsdbRowMergerCleanup(&pReader->status.merger);

×

UNCOV

5726

  taosMemoryFree(pReader->info.pSchema);

×

UNCOV

5728

  tSimpleHashCleanup(pReader->pSchemaMap);

×

UNCOV

5729

  taosMemoryFreeClear(pReader);

×

5732

static int32_t doSuspendCurrentReader(STsdbReader* pCurrentReader) {

×

5733

  int32_t               code = TSDB_CODE_SUCCESS;

×

5734

  int32_t               lino = 0;

×

5735

  SReaderStatus*        pStatus = NULL;

×

5736

  STableBlockScanInfo** p = NULL;

×

5738

  TSDB_CHECK_NULL(pCurrentReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

5740

  pStatus = &pCurrentReader->status;

×

5742

  if (pStatus->loadFromFile) {

×

5743

    tsdbDataFileReaderClose(&pCurrentReader->pFileReader);

×

5745

    SReadCostSummary* pCost = &pCurrentReader->cost;

×

5746

    destroySttBlockReader(pStatus->pLDataIterArray, &pCost->sttCost);

×

5747

    pStatus->pLDataIterArray = taosArrayInit(4, POINTER_BYTES);

×

5748

    TSDB_CHECK_NULL(pStatus->pLDataIterArray, code, lino, _end, terrno);

×

5752

  int32_t step = ASCENDING_TRAVERSE(pCurrentReader->info.order) ? 1 : -1;

×

5753

  int32_t iter = 0;

×

5754

  while ((p = tSimpleHashIterate(pStatus->pTableMap, p, &iter)) != NULL) {

×

5755

    STableBlockScanInfo* pInfo = *(STableBlockScanInfo**)p;

×

5756

    clearBlockScanInfo(pInfo);

×

5761

  pStatus->uidList.currentIndex = 0;

×

5762

  initReaderStatus(pStatus);

×

5764

_end:

×

5765

  if (code != TSDB_CODE_SUCCESS) {

×

5766

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5768

  return code;

×

5771

int32_t tsdbReaderSuspend2(STsdbReader* pReader) {

×

5772

  int32_t code = TSDB_CODE_SUCCESS;

×

5773

  int32_t lino = 0;

×

5775

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

5778

  pReader->status.suspendInvoked = true;  // record the suspend status

×

5780

  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {

×

5781

    if (pReader->step == EXTERNAL_ROWS_PREV) {

×

5782

      code = doSuspendCurrentReader(pReader->innerReader[0]);

×

5783

    } else if (pReader->step == EXTERNAL_ROWS_MAIN) {

×

5784

      code = doSuspendCurrentReader(pReader);

×

5786

      code = doSuspendCurrentReader(pReader->innerReader[1]);

×

5789

    code = doSuspendCurrentReader(pReader);

×

5793

  void* p = pReader->pReadSnap;

×

5794

  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {

×

5795

    tsdbUntakeReadSnap2(pReader, p, false);

×

5796

    pReader->pReadSnap = NULL;

×

5799

  if (pReader->bFilesetDelimited) {

×

5800

    pReader->status.memTableMinKey = INT64_MAX;

×

5801

    pReader->status.memTableMaxKey = INT64_MIN;

×

5803

  pReader->flag = READER_STATUS_SUSPEND;

×

5805

  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {

×

5806

    clearSharedPtr(pReader->innerReader[0]);

×

5807

    clearSharedPtr(pReader->innerReader[1]);

×

5814

  tsdbDebug("reader: %p suspended in this query %s, step:%d", pReader, pReader->idStr, pReader->step);

×

5816

_end:

×

5817

  if (code != TSDB_CODE_SUCCESS) {

×

5818

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

5820

  return code;

×

5823

static int32_t tsdbSetQueryReseek(void* pQHandle) {

×

5824

  int32_t      code = 0;

×

5825

  STsdbReader* pReader = pQHandle;

×

5827

  code = tsdbTryAcquireReader(pReader);

×

5828

  if (code == 0) {

×

5829

    if (pReader->flag == READER_STATUS_SUSPEND) {

×

5830

      code = tsdbReleaseReader(pReader);

×

5831

      return code;

×

5834

    code = tsdbReaderSuspend2(pReader);

×

5835

    (void)tsdbReleaseReader(pReader);

×

5836

    return code;

×

5837

  } else if (code == EBUSY) {

×

5838

    return TSDB_CODE_VND_QUERY_BUSY;

×

5840

    terrno = TAOS_SYSTEM_ERROR(code);

×

5841

    return TSDB_CODE_FAILED;

×

UNCOV

5845

int32_t tsdbReaderResume2(STsdbReader* pReader) {

×

UNCOV

5846

  int32_t               code = TSDB_CODE_SUCCESS;

×

UNCOV

5847

  int32_t               lino = 0;

×

UNCOV

5848

  STableBlockScanInfo** pBlockScanInfo = NULL;

×

UNCOV

5849

  int32_t               numOfTables = 0;

×

UNCOV

5851

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5853

  pBlockScanInfo = pReader->status.pTableIter;

×

UNCOV

5856

  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);

×

UNCOV

5857

  if (numOfTables > 0) {

×

UNCOV

5858

    tsdbTrace("tsdb/reader: %p, take snapshot", pReader);

×

UNCOV

5859

    code = tsdbTakeReadSnap2(pReader, tsdbSetQueryReseek, &pReader->pReadSnap, pReader->idStr);

×

UNCOV

5860

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5864

    pReader->flag = READER_STATUS_NORMAL;

×

UNCOV

5866

    if (pReader->type == TIMEWINDOW_RANGE_CONTAINED) {

×

UNCOV

5867

      code = doOpenReaderImpl(pReader);

×

UNCOV

5868

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5870

      STsdbReader* pPrevReader = pReader->innerReader[0];

×

UNCOV

5871

      STsdbReader* pNextReader = pReader->innerReader[1];

×

UNCOV

5874

      pPrevReader->resBlockInfo.capacity = 1;

×

UNCOV

5875

      code = setSharedPtr(pPrevReader, pReader);

×

UNCOV

5876

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5878

      pNextReader->resBlockInfo.capacity = 1;

×

UNCOV

5879

      code = setSharedPtr(pNextReader, pReader);

×

UNCOV

5880

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5882

      if (pReader->step == 0 || pReader->step == EXTERNAL_ROWS_PREV) {

×

UNCOV

5883

        code = doOpenReaderImpl(pPrevReader);

×

UNCOV

5884

        TSDB_CHECK_CODE(code, lino, _end);

×

5885

      } else if (pReader->step == EXTERNAL_ROWS_MAIN) {

×

5886

        code = doOpenReaderImpl(pReader);

×

5887

        TSDB_CHECK_CODE(code, lino, _end);

×

5889

        code = doOpenReaderImpl(pNextReader);

×

5890

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5895

  tsdbDebug("reader: %p resumed uid %" PRIu64 ", numOfTable:%" PRId32 ", in this query %s", pReader,

×

UNCOV

5898

_end:

×

UNCOV

5899

  if (code != TSDB_CODE_SUCCESS) {

×

5900

    tsdbError("%s failed at line %d since %s, %s", __func__, lino, tstrerror(code),

×

UNCOV

5903

  return code;

×

UNCOV

5906

static int32_t buildFromPreFilesetBuffer(STsdbReader* pReader) {

×

UNCOV

5907

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

5908

  int32_t        lino = 0;

×

UNCOV

5909

  SReaderStatus* pStatus = NULL;

×

UNCOV

5910

  SSDataBlock*   pBlock = NULL;

×

UNCOV

5911

  int32_t        fid = 0;

×

UNCOV

5912

  STimeWindow    win = {0};

×

UNCOV

5914

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5916

  pStatus = &pReader->status;

×

UNCOV

5917

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

5918

  fid = pReader->status.pCurrentFileset->fid;

×

UNCOV

5919

  tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &win.skey, &win.ekey);

×

UNCOV

5921

  int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? win.skey : win.ekey;

×

UNCOV

5922

  code = buildBlockFromBufferSeqForPreFileset(pReader, endKey);

×

UNCOV

5923

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5924

  if (pBlock->info.rows <= 0) {

×

UNCOV

5925

    tsdbDebug("finished pre-fileset %d buffer processing. %s", fid, pReader->idStr);

×

UNCOV

5926

    pStatus->bProcMemPreFileset = false;

×

UNCOV

5927

    pStatus->processingMemPreFileSet = false;

×

UNCOV

5928

    if (pReader->notifyFn) {

×

UNCOV

5929

      STsdReaderNotifyInfo info = {0};

×

UNCOV

5930

      info.duration.filesetId = fid;

×

UNCOV

5931

      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);

×

UNCOV

5932

      tsdbDebug("new duration %d start notification when buffer pre-fileset, %s", fid, pReader->idStr);

×

UNCOV

5936

_end:

×

UNCOV

5937

  if (code != TSDB_CODE_SUCCESS) {

×

5938

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5940

  return code;

×

UNCOV

5943

static int32_t doTsdbNextDataBlockFilesetDelimited(STsdbReader* pReader) {

×

UNCOV

5944

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

5945

  int32_t        lino = 0;

×

UNCOV

5946

  SReaderStatus* pStatus = NULL;

×

UNCOV

5947

  SSDataBlock*   pBlock = NULL;

×

UNCOV

5949

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

5951

  pStatus = &pReader->status;

×

UNCOV

5952

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

5954

  if (pStatus->loadFromFile) {

×

UNCOV

5955

    if (pStatus->bProcMemPreFileset) {

×

UNCOV

5956

      code = buildFromPreFilesetBuffer(pReader);

×

UNCOV

5957

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5958

      if (pBlock->info.rows > 0) {

×

UNCOV

5959

        goto _end;

×

UNCOV

5963

    code = buildBlockFromFiles(pReader);

×

UNCOV

5964

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5966

    tsdbTrace("block from file rows: %" PRId64 ", will process pre-file set buffer: %d. %s", pBlock->info.rows,

×

UNCOV

5968

    if (pStatus->bProcMemPreFileset) {

×

UNCOV

5969

      if (pBlock->info.rows > 0) {

×

UNCOV

5970

        if (pReader->notifyFn && !pReader->status.processingMemPreFileSet) {

×

5971

          int32_t              fid = pReader->status.pCurrentFileset->fid;

×

5972

          STsdReaderNotifyInfo info = {0};

×

5973

          info.duration.filesetId = fid;

×

5974

          pReader->notifyFn(TSD_READER_NOTIFY_NEXT_DURATION_BLOCK, &info, pReader->notifyParam);

×

5977

        pStatus->bProcMemPreFileset = false;

×

UNCOV

5981

    if (pBlock->info.rows <= 0) {

×

UNCOV

5982

      code = resetTableListIndex(&pReader->status, pReader->idStr);

×

UNCOV

5983

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5985

      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;

×

UNCOV

5986

      code = buildBlockFromBufferSequentially(pReader, endKey);

×

UNCOV

5987

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5990

    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;

×

UNCOV

5991

    code = buildBlockFromBufferSequentially(pReader, endKey);

×

UNCOV

5992

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

5995

_end:

×

UNCOV

5996

  if (code != TSDB_CODE_SUCCESS) {

×

5997

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

5999

  return code;

×

UNCOV

6002

static int32_t doTsdbNextDataBlockFilesFirst(STsdbReader* pReader) {

×

UNCOV

6003

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

6004

  int32_t        lino = 0;

×

UNCOV

6005

  SReaderStatus* pStatus = NULL;

×

UNCOV

6006

  SSDataBlock*   pBlock = NULL;

×

UNCOV

6008

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6010

  pStatus = &pReader->status;

×

UNCOV

6011

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

6013

  if (pStatus->loadFromFile) {

×

UNCOV

6014

    code = buildBlockFromFiles(pReader);

×

UNCOV

6015

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6017

    if (pBlock->info.rows <= 0) {

×

UNCOV

6018

      code = resetTableListIndex(&pReader->status, pReader->idStr);

×

UNCOV

6019

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6021

      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;

×

UNCOV

6022

      code = buildBlockFromBufferSequentially(pReader, endKey);

×

UNCOV

6023

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6026

    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;

×

UNCOV

6027

    code = buildBlockFromBufferSequentially(pReader, endKey);

×

UNCOV

6028

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6031

_end:

×

UNCOV

6032

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

6033

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6035

  return code;

×

UNCOV

6038

static int32_t doTsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {

×

UNCOV

6039

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

6040

  int32_t      lino = 0;

×

UNCOV

6041

  SSDataBlock* pBlock = NULL;

×

UNCOV

6043

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6046

  pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

6047

  blockDataCleanup(pBlock);

×

UNCOV

6049

  *hasNext = false;

×

UNCOV

6051

  SReaderStatus* pStatus = &pReader->status;

×

UNCOV

6052

  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {

×

UNCOV

6053

    goto _end;

×

UNCOV

6056

  if (!pReader->bFilesetDelimited) {

×

UNCOV

6057

    code = doTsdbNextDataBlockFilesFirst(pReader);

×

UNCOV

6059

    code = doTsdbNextDataBlockFilesetDelimited(pReader);

×

UNCOV

6062

  *hasNext = pBlock->info.rows > 0;

×

UNCOV

6063

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6065

_end:

×

UNCOV

6066

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

6067

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6069

  return code;

×

UNCOV

6072

int32_t tsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {

×

UNCOV

6073

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

6074

  int32_t        lino = 0;

×

UNCOV

6075

  SReaderStatus* pStatus = NULL;

×

UNCOV

6076

  bool           acquired = false;

×

UNCOV

6078

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6079

  TSDB_CHECK_NULL(hasNext, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6081

  *hasNext = false;

×

UNCOV

6083

  code = pReader->code;

×

UNCOV

6084

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6086

  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->step == EXTERNAL_ROWS_NEXT) {

×

UNCOV

6087

    goto _end;

×

UNCOV

6090

  pStatus = &pReader->status;

×

UNCOV

6102

  code = tsdbAcquireReader(pReader);

×

UNCOV

6103

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6104

  acquired = true;

×

UNCOV

6106

  tsdbTrace("tsdb/read: %p, take read mutex, code: %d", pReader, code);

×

UNCOV

6108

  if (pReader->flag == READER_STATUS_SUSPEND) {

×

UNCOV

6109

    code = tsdbReaderResume2(pReader);

×

UNCOV

6110

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6113

  if (pReader->innerReader[0] != NULL && pReader->step == 0) {

×

UNCOV

6114

    code = doTsdbNextDataBlock2(pReader->innerReader[0], hasNext);

×

UNCOV

6115

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6117

    pReader->step = EXTERNAL_ROWS_PREV;

×

UNCOV

6118

    if (*hasNext) {

×

UNCOV

6119

      pStatus = &pReader->innerReader[0]->status;

×

UNCOV

6120

      if (pStatus->composedDataBlock) {

×

UNCOV

6121

        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);

×

UNCOV

6122

        code = tsdbReleaseReader(pReader);

×

UNCOV

6123

        acquired = false;

×

UNCOV

6124

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6127

      return code;

×

UNCOV

6131

  if (pReader->step == EXTERNAL_ROWS_PREV) {

×

UNCOV

6133

    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {

×

UNCOV

6134

      code = doOpenReaderImpl(pReader);

×

UNCOV

6137

    int32_t step = 1;

×

UNCOV

6138

    resetAllDataBlockScanInfo(pReader->status.pTableMap, pReader->innerReader[0]->info.window.ekey, step);

×

UNCOV

6139

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6141

    pReader->step = EXTERNAL_ROWS_MAIN;

×

UNCOV

6144

  code = doTsdbNextDataBlock2(pReader, hasNext);

×

UNCOV

6145

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6147

  if (*hasNext) {

×

UNCOV

6148

    if (pStatus->composedDataBlock) {

×

UNCOV

6149

      tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);

×

UNCOV

6150

      code = tsdbReleaseReader(pReader);

×

UNCOV

6151

      acquired = false;

×

UNCOV

6152

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6154

    return code;

×

UNCOV

6157

  if (pReader->step == EXTERNAL_ROWS_MAIN && pReader->innerReader[1] != NULL) {

×

UNCOV

6159

    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {

×

UNCOV

6160

      code = doOpenReaderImpl(pReader->innerReader[1]);

×

UNCOV

6163

    int32_t step = -1;

×

UNCOV

6164

    resetAllDataBlockScanInfo(pReader->innerReader[1]->status.pTableMap, pReader->info.window.ekey, step);

×

UNCOV

6165

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6167

    code = doTsdbNextDataBlock2(pReader->innerReader[1], hasNext);

×

UNCOV

6168

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6170

    pReader->step = EXTERNAL_ROWS_NEXT;

×

UNCOV

6171

    if (*hasNext) {

×

UNCOV

6172

      pStatus = &pReader->innerReader[1]->status;

×

UNCOV

6173

      if (pStatus->composedDataBlock) {

×

UNCOV

6174

        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);

×

UNCOV

6175

        code = tsdbReleaseReader(pReader);

×

UNCOV

6176

        acquired = false;

×

UNCOV

6177

        TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6180

      return code;

×

UNCOV

6184

  tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);

×

UNCOV

6185

  code = tsdbReleaseReader(pReader);

×

UNCOV

6186

  acquired = false;

×

UNCOV

6187

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6189

_end:

×

UNCOV

6190

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

6191

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6193

  if (acquired) {

×

UNCOV

6194

    tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);

×

UNCOV

6195

    (void)tsdbReleaseReader(pReader);

×

UNCOV

6197

  return code;

×

UNCOV

6200

static int32_t doFillNullColSMA(SBlockLoadSuppInfo* pSup, int32_t numOfRows, int32_t numOfCols,

×

UNCOV

6203

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

6204

  int32_t lino = 0;

×

UNCOV

6205

  int32_t i = 0, j = 0;

×

UNCOV

6206

  int32_t size = 0;

×

UNCOV

6208

  TSDB_CHECK_NULL(pSup, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6210

  size = (int32_t)TARRAY2_SIZE(&pSup->colAggArray);

×

UNCOV

6211

  code = TARRAY2_INSERT_PTR(&pSup->colAggArray, 0, pTsAgg);

×

UNCOV

6212

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6214

  size++;

×

UNCOV

6216

  while (j < numOfCols && i < size) {

×

UNCOV

6217

    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];

×

UNCOV

6218

    if (pAgg->colId == pSup->colId[j]) {

×

UNCOV

6219

      i += 1;

×

UNCOV

6220

      j += 1;

×

UNCOV

6221

    } else if (pAgg->colId < pSup->colId[j]) {

×

UNCOV

6222

      i += 1;

×

6223

    } else if (pSup->colId[j] < pAgg->colId) {

×

6224

      if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {

×

6225

        SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};

×

6226

        code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);

×

6227

        TSDB_CHECK_CODE(code, lino, _end);

×

6229

        i += 1;

×

6230

        size++;

×

6232

      j += 1;

×

UNCOV

6236

  while (j < numOfCols) {

×

UNCOV

6237

    if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {

×

UNCOV

6238

      SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};

×

UNCOV

6239

      code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);

×

UNCOV

6240

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6242

      i += 1;

×

UNCOV

6244

    j++;

×

UNCOV

6247

_end:

×

UNCOV

6248

  if (code != TSDB_CODE_SUCCESS) {

×

6249

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6251

  return code;

×

UNCOV

6254

int32_t tsdbRetrieveDatablockSMA2(STsdbReader* pReader, SSDataBlock* pDataBlock, bool* allHave, bool* hasNullSMA) {

×

UNCOV

6255

  int32_t             code = TSDB_CODE_SUCCESS;

×

UNCOV

6256

  int32_t             lino = 0;

×

UNCOV

6257

  SColumnDataAgg**    pBlockSMA = NULL;

×

UNCOV

6258

  SFileDataBlockInfo* pBlockInfo = NULL;

×

UNCOV

6260

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6261

  TSDB_CHECK_NULL(pDataBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6262

  TSDB_CHECK_NULL(allHave, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6264

  pBlockSMA = &pDataBlock->pBlockAgg;

×

UNCOV

6265

  *allHave = false;

×

UNCOV

6266

  *pBlockSMA = NULL;

×

UNCOV

6268

  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {

×

UNCOV

6269

    goto _end;

×

UNCOV

6273

  if (pReader->status.composedDataBlock || (!pReader->suppInfo.smaValid)) {

×

UNCOV

6274

    goto _end;

×

UNCOV

6277

  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

6278

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6280

  SBlockLoadSuppInfo* pSup = &pReader->suppInfo;

×

UNCOV

6282

  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

6283

  if (pResBlock->info.id.uid != pBlockInfo->uid) {

×

6284

    goto _end;

×

UNCOV

6288

  TARRAY2_CLEAR(&pSup->colAggArray, 0);

×

UNCOV

6291

  blockInfoToRecord(&pRecord, pBlockInfo, pSup);

×

UNCOV

6292

  code = tsdbDataFileReadBlockSma(pReader->pFileReader, &pRecord, &pSup->colAggArray);

×

UNCOV

6293

  if (code != TSDB_CODE_SUCCESS) {

×

6294

    tsdbDebug("vgId:%d, failed to load block SMA for uid %" PRIu64 ", code:%s, %s", 0, pBlockInfo->uid, tstrerror(code),

×

6296

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6299

  if (pSup->colAggArray.size > 0) {

×

UNCOV

6300

    *allHave = true;

×

6302

    *pBlockSMA = NULL;

×

6303

    goto _end;

×

UNCOV

6307

  SColumnDataAgg* pTsAgg = &pSup->tsColAgg;

×

UNCOV

6309

  pTsAgg->numOfNull = 0;

×

UNCOV

6310

  pTsAgg->colId = PRIMARYKEY_TIMESTAMP_COL_ID;

×

UNCOV

6311

  pTsAgg->min = pResBlock->info.window.skey;

×

UNCOV

6312

  pTsAgg->max = pResBlock->info.window.ekey;

×

UNCOV

6315

  size_t numOfCols = pSup->numOfCols;

×

UNCOV

6317

  if (pResBlock->pBlockAgg == NULL) {

×

UNCOV

6318

    size_t num = taosArrayGetSize(pResBlock->pDataBlock);

×

UNCOV

6319

    pResBlock->pBlockAgg = taosMemoryCalloc(num, sizeof(SColumnDataAgg));

×

UNCOV

6320

    TSDB_CHECK_NULL(pResBlock->pBlockAgg, code, lino, _end, terrno);

×

UNCOV

6321

    for (int i = 0; i < num; ++i) {

×

UNCOV

6322

      pResBlock->pBlockAgg[i].colId = -1;

×

UNCOV

6327

  code = doFillNullColSMA(pSup, pBlockInfo->numRow, numOfCols, pTsAgg);

×

UNCOV

6328

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6330

  size_t size = pSup->colAggArray.size;

×

UNCOV

6332

  int32_t i = 0, j = 0;

×

UNCOV

6333

  while (j < numOfCols && i < size) {

×

UNCOV

6334

    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];

×

UNCOV

6335

    if (pAgg->colId == pSup->colId[j]) {

×

UNCOV

6336

      pResBlock->pBlockAgg[pSup->slotId[j]] = *pAgg;

×

UNCOV

6337

      i += 1;

×

UNCOV

6338

      j += 1;

×

UNCOV

6339

    } else if (pAgg->colId < pSup->colId[j]) {

×

UNCOV

6340

      i += 1;

×

UNCOV

6341

    } else if (pSup->colId[j] < pAgg->colId) {

×

6342

      pResBlock->pBlockAgg[pSup->slotId[j]].colId = -1;

×

6343

      *allHave = false;

×

6344

      j += 1;

×

UNCOV

6348

  *pBlockSMA = pResBlock->pBlockAgg;

×

UNCOV

6349

  pReader->cost.smaDataLoad += 1;

×

UNCOV

6352

  pReader->cost.smaLoadTime += 0;  // elapsedTime;

×

UNCOV

6354

  tsdbDebug("vgId:%d, succeed to load block SMA for uid %" PRIu64 ", %s", 0, pBlockInfo->uid, pReader->idStr);

×

UNCOV

6356

_end:

×

UNCOV

6357

  if (code != TSDB_CODE_SUCCESS) {

×

6358

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6360

  return code;

×

UNCOV

6363

static int32_t doRetrieveDataBlock(STsdbReader* pReader, SSDataBlock** pBlock) {

×

UNCOV

6364

  int32_t              code = TSDB_CODE_SUCCESS;

×

UNCOV

6365

  int32_t              lino = 0;

×

UNCOV

6366

  SReaderStatus*       pStatus = NULL;

×

UNCOV

6367

  SFileDataBlockInfo*  pBlockInfo = NULL;

×

UNCOV

6368

  STableBlockScanInfo* pBlockScanInfo = NULL;

×

UNCOV

6369

  bool                 reset = false;

×

UNCOV

6371

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6372

  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6374

  pStatus = &pReader->status;

×

UNCOV

6375

  *pBlock = NULL;

×

UNCOV

6377

  code = getCurrentBlockInfo(&pStatus->blockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

6378

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6380

  code = pReader->code;

×

UNCOV

6381

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6383

  code = getTableBlockScanInfo(pStatus->pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);

×

UNCOV

6384

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6386

  reset = true;

×

UNCOV

6387

  code = doLoadFileBlockData(pReader, &pStatus->blockIter, &pStatus->fileBlockData, pBlockScanInfo->uid);

×

UNCOV

6388

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6390

  code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);

×

UNCOV

6391

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6393

  *pBlock = pReader->resBlockInfo.pResBlock;

×

UNCOV

6395

_end:

×

UNCOV

6396

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

6397

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6398

    if (reset) {

×

UNCOV

6399

      tBlockDataReset(&pStatus->fileBlockData);

×

UNCOV

6402

  return code;

×

UNCOV

6405

int32_t tsdbRetrieveDataBlock2(STsdbReader* pReader, SSDataBlock** pBlock, SArray* pIdList) {

×

UNCOV

6406

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

6407

  int32_t      lino = 0;

×

UNCOV

6408

  STsdbReader* pTReader = NULL;

×

UNCOV

6410

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6411

  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6413

  *pBlock = NULL;

×

UNCOV

6415

  pTReader = pReader;

×

UNCOV

6416

  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {

×

UNCOV

6417

    if (pReader->step == EXTERNAL_ROWS_PREV) {

×

UNCOV

6418

      pTReader = pReader->innerReader[0];

×

UNCOV

6419

    } else if (pReader->step == EXTERNAL_ROWS_NEXT) {

×

UNCOV

6420

      pTReader = pReader->innerReader[1];

×

UNCOV

6424

  SReaderStatus* pStatus = &pTReader->status;

×

UNCOV

6425

  if (pStatus->composedDataBlock || pReader->info.execMode == READER_EXEC_ROWS) {

×

UNCOV

6428

    *pBlock = pTReader->resBlockInfo.pResBlock;

×

UNCOV

6429

    goto _end;

×

UNCOV

6432

  code = doRetrieveDataBlock(pTReader, pBlock);

×

UNCOV

6434

  tsdbTrace("tsdb/read-retrieve: %p, unlock read mutex", pReader);

×

UNCOV

6435

  (void) tsdbReleaseReader(pReader);

×

UNCOV

6436

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6440

_end:

×

UNCOV

6441

  if (code != TSDB_CODE_SUCCESS) {

×

UNCOV

6442

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6444

  return code;

×

UNCOV

6447

int32_t tsdbReaderReset2(STsdbReader* pReader, SQueryTableDataCond* pCond) {

×

UNCOV

6448

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

6449

  int32_t lino = 0;

×

UNCOV

6450

  bool    acquired = false;

×

UNCOV

6452

  tsdbTrace("tsdb/reader-reset: %p, take read mutex", pReader);

×

UNCOV

6453

  code = tsdbAcquireReader(pReader);

×

UNCOV

6454

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6455

  acquired = true;

×

UNCOV

6457

  if (pReader->flag == READER_STATUS_SUSPEND) {

×

UNCOV

6458

    code = tsdbReaderResume2(pReader);

×

UNCOV

6459

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6462

  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->pReadSnap == NULL) {

×

UNCOV

6463

    tsdbDebug("tsdb reader reset return %p, %s", pReader->pReadSnap, pReader->idStr);

×

UNCOV

6464

    code = tsdbReleaseReader(pReader);

×

UNCOV

6465

    acquired = false;

×

UNCOV

6466

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6467

    goto _end;

×

UNCOV

6470

  SReaderStatus*  pStatus = &pReader->status;

×

UNCOV

6471

  SDataBlockIter* pBlockIter = &pStatus->blockIter;

×

UNCOV

6473

  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6474

  pReader->info.order = pCond->order;

×

UNCOV

6475

  pReader->type = TIMEWINDOW_RANGE_CONTAINED;

×

UNCOV

6476

  code = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows, &pReader->info.window);

×

UNCOV

6477

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6478

  pStatus->loadFromFile = true;

×

UNCOV

6479

  pStatus->pTableIter = NULL;

×

UNCOV

6482

  memset(&pReader->suppInfo.tsColAgg, 0, sizeof(SColumnDataAgg));

×

UNCOV

6484

  pReader->suppInfo.tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;

×

UNCOV

6485

  tsdbDataFileReaderClose(&pReader->pFileReader);

×

UNCOV

6487

  int32_t numOfTables = tSimpleHashGetSize(pStatus->pTableMap);

×

UNCOV

6489

  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);

×

UNCOV

6490

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6492

  code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);

×

UNCOV

6493

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6495

  code = resetTableListIndex(&pReader->status, pReader->idStr);

×

UNCOV

6496

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6498

  bool    asc = ASCENDING_TRAVERSE(pReader->info.order);

×

UNCOV

6499

  int32_t step = asc ? 1 : -1;

×

UNCOV

6500

  int64_t ts = 0;

×

UNCOV

6501

  if (asc) {

×

UNCOV

6502

    ts = (pReader->info.window.skey > INT64_MIN) ? pReader->info.window.skey - 1 : pReader->info.window.skey;

×

UNCOV

6504

    ts = (pReader->info.window.ekey < INT64_MAX) ? pReader->info.window.ekey + 1 : pReader->info.window.ekey;

×

UNCOV

6506

  resetAllDataBlockScanInfo(pStatus->pTableMap, ts, step);

×

UNCOV

6509

  if (pStatus->fileIter.numOfFiles == 0) {

×

UNCOV

6510

    pStatus->loadFromFile = false;

×

UNCOV

6511

    code = resetTableListIndex(pStatus, pReader->idStr);

×

UNCOV

6512

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6514

    code = initForFirstBlockInFile(pReader, pBlockIter);

×

UNCOV

6515

    if (code != TSDB_CODE_SUCCESS) {

×

6516

      tsdbError("%p reset reader failed, numOfTables:%d, query range:%" PRId64 " - %" PRId64 " in query %s", pReader,

×

6518

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6522

  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%" PRId64 ", query range:%" PRId64 " - %" PRId64

×

UNCOV

6527

  code = tsdbReleaseReader(pReader);

×

UNCOV

6528

  acquired = false;

×

UNCOV

6529

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6531

_end:

×

UNCOV

6532

  if (code != TSDB_CODE_SUCCESS) {

×

6533

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6535

  if (acquired) {

×

6536

    (void)tsdbReleaseReader(pReader);

×

UNCOV

6538

  return code;

×

UNCOV

6541

static int32_t getBucketIndex(int32_t startRow, int32_t bucketRange, int32_t numOfRows, int32_t numOfBucket) {

×

UNCOV

6542

  if (numOfRows < startRow) {

×

6543

    return 0;

×

UNCOV

6545

  int32_t bucketIndex = ((numOfRows - startRow) / bucketRange);

×

UNCOV

6546

  if (bucketIndex == numOfBucket) {

×

6547

    bucketIndex -= 1;

×

UNCOV

6549

  return bucketIndex;

×

UNCOV

6552

int32_t tsdbGetFileBlocksDistInfo2(STsdbReader* pReader, STableBlockDistInfo* pTableBlockInfo) {

×

UNCOV

6553

  int32_t       code = TSDB_CODE_SUCCESS;

×

UNCOV

6554

  int32_t       lino = 0;

×

UNCOV

6555

  const int32_t numOfBuckets = 20.0;

×

UNCOV

6556

  bool          acquired = false;

×

UNCOV

6558

  TSDB_CHECK_NULL(pTableBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6560

  pTableBlockInfo->totalSize = 0;

×

UNCOV

6561

  pTableBlockInfo->totalRows = 0;

×

UNCOV

6562

  pTableBlockInfo->numOfVgroups = 1;

×

UNCOV

6565

  code = tsdbAcquireReader(pReader);

×

UNCOV

6566

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6567

  acquired = true;

×

UNCOV

6569

  if (pReader->flag == READER_STATUS_SUSPEND) {

×

UNCOV

6570

    code = tsdbReaderResume2(pReader);

×

UNCOV

6571

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6574

  SMergeTreeConf conf = {

×

UNCOV

6576

      .pSchema = pReader->info.pSchema,

×

UNCOV

6577

      .pCols = pReader->suppInfo.colId,

×

UNCOV

6578

      .numOfCols = pReader->suppInfo.numOfCols,

×

UNCOV

6579

      .suid = pReader->info.suid,

×

UNCOV

6582

  SReaderStatus* pStatus = &pReader->status;

×

UNCOV

6583

  if (pStatus->pCurrentFileset != NULL) {

×

UNCOV

6584

    pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,

×

UNCOV

6585

                                                           pReader->pTsdb, &conf, pReader->idStr);

×

UNCOV

6588

  STsdbCfg* pc = &pReader->pTsdb->pVnode->config.tsdbCfg;

×

UNCOV

6589

  pTableBlockInfo->defMinRows = pc->minRows;

×

UNCOV

6590

  pTableBlockInfo->defMaxRows = pc->maxRows;

×

UNCOV

6592

  int32_t bucketRange = ceil(((double)(pc->maxRows - pc->minRows)) / numOfBuckets);

×

UNCOV

6594

  pTableBlockInfo->numOfFiles += 1;

×

UNCOV

6596

  int32_t numOfTables = (int32_t)tSimpleHashGetSize(pStatus->pTableMap);

×

UNCOV

6598

  SDataBlockIter* pBlockIter = &pStatus->blockIter;

×

UNCOV

6599

  pTableBlockInfo->numOfFiles += pStatus->fileIter.numOfFiles;

×

UNCOV

6601

  if (pBlockIter->numOfBlocks > 0) {

×

UNCOV

6602

    pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;

×

UNCOV

6605

  pTableBlockInfo->numOfTables = numOfTables;

×

UNCOV

6606

  bool hasNext = (pBlockIter->numOfBlocks > 0);

×

UNCOV

6609

    if (hasNext) {

×

UNCOV

6610

      SFileDataBlockInfo* pBlockInfo = NULL;

×

UNCOV

6611

      code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);

×

UNCOV

6612

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6614

      int32_t numOfRows = pBlockInfo->numRow;

×

UNCOV

6616

      pTableBlockInfo->totalRows += numOfRows;

×

UNCOV

6618

      if (numOfRows > pTableBlockInfo->maxRows) {

×

UNCOV

6619

        pTableBlockInfo->maxRows = numOfRows;

×

UNCOV

6622

      if (numOfRows < pTableBlockInfo->minRows) {

×

UNCOV

6623

        pTableBlockInfo->minRows = numOfRows;

×

UNCOV

6626

      pTableBlockInfo->totalSize += pBlockInfo->blockSize;

×

UNCOV

6628

      int32_t bucketIndex = getBucketIndex(pTableBlockInfo->defMinRows, bucketRange, numOfRows, numOfBuckets);

×

UNCOV

6629

      pTableBlockInfo->blockRowsHisto[bucketIndex]++;

×

UNCOV

6631

      hasNext = blockIteratorNext(&pStatus->blockIter);

×

UNCOV

6633

      code = initForFirstBlockInFile(pReader, pBlockIter);

×

UNCOV

6634

      TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6635

      if (pStatus->loadFromFile == false) {

×

UNCOV

6636

        break;

×

UNCOV

6640

      if (pStatus->pCurrentFileset != NULL) {

×

UNCOV

6641

        pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,

×

UNCOV

6642

                                                               pReader->pTsdb, &conf, pReader->idStr);

×

UNCOV

6645

      pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;

×

UNCOV

6646

      hasNext = (pBlockIter->numOfBlocks > 0);

×

UNCOV

6651

_end:

×

UNCOV

6652

  if (code != TSDB_CODE_SUCCESS) {

×

6653

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6655

  if (acquired) {

×

UNCOV

6656

    (void)tsdbReleaseReader(pReader);

×

UNCOV

6658

  return code;

×

UNCOV

6661

static void getMemTableTimeRange(STsdbReader* pReader, int64_t* pMaxKey, int64_t* pMinKey) {

×

UNCOV

6662

  SReaderStatus* pStatus = &pReader->status;

×

UNCOV

6664

  int32_t iter = 0;

×

UNCOV

6665

  int64_t maxKey = INT64_MIN;

×

UNCOV

6666

  int64_t minKey = INT64_MAX;

×

UNCOV

6668

  void* pHashIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);

×

UNCOV

6669

  while (pHashIter != NULL) {

×

UNCOV

6670

    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pHashIter;

×

UNCOV

6672

    STbData* d = NULL;

×

UNCOV

6673

    if (pReader->pReadSnap->pMem != NULL) {

×

UNCOV

6674

      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);

×

UNCOV

6675

      if (d != NULL) {

×

UNCOV

6676

        if (d->maxKey > maxKey) {

×

UNCOV

6677

          maxKey = d->maxKey;

×

UNCOV

6679

        if (d->minKey < minKey) {

×

UNCOV

6680

          minKey = d->minKey;

×

UNCOV

6685

    STbData* di = NULL;

×

UNCOV

6686

    if (pReader->pReadSnap->pIMem != NULL) {

×

UNCOV

6687

      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);

×

UNCOV

6688

      if (di != NULL) {

×

UNCOV

6689

        if (di->maxKey > maxKey) {

×

UNCOV

6690

          maxKey = di->maxKey;

×

UNCOV

6692

        if (di->minKey < minKey) {

×

UNCOV

6693

          minKey = di->minKey;

×

UNCOV

6699

    pHashIter = tSimpleHashIterate(pStatus->pTableMap, pHashIter, &iter);

×

UNCOV

6702

  *pMaxKey = maxKey;

×

UNCOV

6703

  *pMinKey = minKey;

×

UNCOV

6704

×

UNCOV

6706

int64_t tsdbGetNumOfRowsInMemTable2(STsdbReader* pReader, uint32_t* rows) {

×

UNCOV

6707

  int32_t        code = TSDB_CODE_SUCCESS;

×

UNCOV

6708

  int32_t        lino = 0;

×

UNCOV

6709

  SReaderStatus* pStatus = NULL;

×

UNCOV

6710

  bool           acquired = false;

×

UNCOV

6712

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6713

  TSDB_CHECK_NULL(rows, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6715

  *rows = 0;

×

UNCOV

6716

  pStatus = &pReader->status;

×

UNCOV

6717

  code = tsdbAcquireReader(pReader);

×

UNCOV

6718

  TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6719

  acquired = true;

×

UNCOV

6721

  if (pReader->flag == READER_STATUS_SUSPEND) {

×

UNCOV

6722

    code = tsdbReaderResume2(pReader);

×

UNCOV

6723

    TSDB_CHECK_CODE(code, lino, _end);

×

UNCOV

6726

  int32_t iter = 0;

×

UNCOV

6727

  pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);

×

UNCOV

6729

  while (pStatus->pTableIter != NULL) {

×

UNCOV

6730

    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;

×

UNCOV

6732

    STbData* d = NULL;

×

UNCOV

6733

    if (pReader->pReadSnap->pMem != NULL) {

×

UNCOV

6734

      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);

×

UNCOV

6735

      if (d != NULL) {

×

UNCOV

6736

        *rows += tsdbGetNRowsInTbData(d);

×

UNCOV

6740

    STbData* di = NULL;

×

UNCOV

6741

    if (pReader->pReadSnap->pIMem != NULL) {

×

UNCOV

6742

      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);

×

UNCOV

6743

      if (di != NULL) {

×

UNCOV

6744

        *rows += tsdbGetNRowsInTbData(di);

×

UNCOV

6749

    pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, pStatus->pTableIter, &iter);

×

UNCOV

6752

_end:

×

UNCOV

6753

  if (code != TSDB_CODE_SUCCESS) {

×

6754

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6756

  if (acquired) {

×

UNCOV

6757

    (void)tsdbReleaseReader(pReader);

×

UNCOV

6759

  return code;

×

UNCOV

6762

int32_t tsdbGetTableSchema(SMeta* pMeta, int64_t uid, STSchema** pSchema, int64_t* suid) {

×

UNCOV

6763

  SMetaReader mr = {0};

×

UNCOV

6764

  metaReaderDoInit(&mr, pMeta, META_READER_LOCK);

×

UNCOV

6765

  int32_t code = metaReaderGetTableEntryByUidCache(&mr, uid);

×

UNCOV

6766

  if (code != TSDB_CODE_SUCCESS) {

×

6767

    code = TSDB_CODE_TDB_INVALID_TABLE_ID;

×

6768

    metaReaderClear(&mr);

×

6769

    return code;

×

UNCOV

6772

  *suid = 0;

×

UNCOV

6775

  if (mr.me.type == TSDB_CHILD_TABLE) {

×

UNCOV

6776

    tDecoderClear(&mr.coder);

×

UNCOV

6777

    *suid = mr.me.ctbEntry.suid;

×

UNCOV

6778

    code = metaReaderGetTableEntryByUidCache(&mr, *suid);

×

UNCOV

6779

    if (code != TSDB_CODE_SUCCESS) {

×

6780

      code = TSDB_CODE_TDB_INVALID_TABLE_ID;

×

6781

      metaReaderClear(&mr);

×

6782

      return code;

×

UNCOV

6784

  } else if (mr.me.type == TSDB_NORMAL_TABLE) {  // do nothing

×

6786

    code = TSDB_CODE_INVALID_PARA;

×

6787

    tsdbError("invalid mr.me.type:%d, code:%s", mr.me.type, tstrerror(code));

×

6788

    metaReaderClear(&mr);

×

6789

    return code;

×

UNCOV

6792

  metaReaderClear(&mr);

×

UNCOV

6795

  code = metaGetTbTSchemaEx(pMeta, *suid, uid, -1, pSchema);

×

UNCOV

6796

  return code;

×

UNCOV

6799

int32_t tsdbTakeReadSnap2(STsdbReader* pReader, _query_reseek_func_t reseek, STsdbReadSnap** ppSnap, const char* id) {

×

UNCOV

6800

  int32_t        code = 0;

×

UNCOV

6801

  STsdb*         pTsdb = pReader->pTsdb;

×

UNCOV

6802

  SVersionRange* pRange = &pReader->info.verRange;

×

UNCOV

6803

  int32_t        lino = 0;

×

UNCOV

6804

  *ppSnap = NULL;

×

UNCOV

6807

  code = taosThreadMutexLock(&pTsdb->mutex);

×

UNCOV

6808

  if (code != TSDB_CODE_SUCCESS) {

×

6809

    tsdbError("%s failed to lock tsdb, code:%s", id, tstrerror(code));

×

6810

    return code;

×

UNCOV

6814

  STsdbReadSnap* pSnap = (STsdbReadSnap*)taosMemoryCalloc(1, sizeof(STsdbReadSnap));

×

UNCOV

6815

  if (pSnap == NULL) {

×

6816

    (void) taosThreadMutexUnlock(&pTsdb->mutex);

×

6817

    TSDB_CHECK_NULL(pSnap, code, lino, _exit, terrno);

×

UNCOV

6821

  if (pTsdb->mem && (pRange->minVer <= pTsdb->mem->maxVer && pRange->maxVer >= pTsdb->mem->minVer)) {

×

UNCOV

6822

    pSnap->pMem = pTsdb->mem;

×

UNCOV

6823

    pSnap->pNode = taosMemoryMalloc(sizeof(*pSnap->pNode));

×

UNCOV

6824

    if (pSnap->pNode == NULL) {

×

6825

      (void) taosThreadMutexUnlock(&pTsdb->mutex);

×

6826

      TSDB_CHECK_NULL(pSnap->pNode, code, lino, _exit, terrno);

×

UNCOV

6829

    pSnap->pNode->pQHandle = pReader;

×

UNCOV

6830

    pSnap->pNode->reseek = reseek;

×

UNCOV

6832

    code = tsdbRefMemTable(pTsdb->mem, pSnap->pNode);

×

UNCOV

6833

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

6836

  if (pTsdb->imem && (pRange->minVer <= pTsdb->imem->maxVer && pRange->maxVer >= pTsdb->imem->minVer)) {

×

UNCOV

6837

    pSnap->pIMem = pTsdb->imem;

×

UNCOV

6838

    pSnap->pINode = taosMemoryMalloc(sizeof(*pSnap->pINode));

×

UNCOV

6839

    if (pSnap->pINode == NULL) {

×

6840

      code = terrno;

×

6842

      if (pTsdb->mem && pSnap->pNode) {

×

6843

        tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem

×

6846

      (void) taosThreadMutexUnlock(&pTsdb->mutex);

×

6847

      goto _exit;

×

UNCOV

6850

    pSnap->pINode->pQHandle = pReader;

×

UNCOV

6851

    pSnap->pINode->reseek = reseek;

×

UNCOV

6853

    code = tsdbRefMemTable(pTsdb->imem, pSnap->pINode);

×

UNCOV

6854

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

6858

  code = tsdbFSCreateRefSnapshotWithoutLock(pTsdb->pFS, &pSnap->pfSetArray);

×

UNCOV

6859

  if (code) {

×

6860

    if (pSnap->pNode) {

×

6861

      tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem

×

6864

    if (pSnap->pINode) {

×

6865

      tsdbUnrefMemTable(pTsdb->imem, pSnap->pINode, true);

×

6868

    (void) taosThreadMutexUnlock(&pTsdb->mutex);

×

6869

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

6873

  (void) taosThreadMutexUnlock(&pTsdb->mutex);

×

UNCOV

6874

  *ppSnap = pSnap;

×

UNCOV

6876

  tsdbTrace("%s vgId:%d, take read snapshot", id, TD_VID(pTsdb->pVnode));

×

UNCOV

6877

  return code;

×

6879

_exit:

×

6880

  tsdbError("%s vgId:%d take read snapshot failed, line:%d code:%s", id, TD_VID(pTsdb->pVnode), lino, tstrerror(code));

×

6882

  if (pSnap) {

×

6883

    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);

×

6884

    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);

×

6885

    taosMemoryFree(pSnap);

×

6887

  return code;

×

UNCOV

6890

void tsdbUntakeReadSnap2(STsdbReader* pReader, STsdbReadSnap* pSnap, bool proactive) {

×

UNCOV

6891

  STsdb* pTsdb = pReader->pTsdb;

×

UNCOV

6893

  if (pSnap) {

×

UNCOV

6894

    if (pSnap->pMem) {

×

UNCOV

6895

      tsdbUnrefMemTable(pSnap->pMem, pSnap->pNode, proactive);

×

UNCOV

6898

    if (pSnap->pIMem) {

×

UNCOV

6899

      tsdbUnrefMemTable(pSnap->pIMem, pSnap->pINode, proactive);

×

UNCOV

6902

    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);

×

UNCOV

6903

    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);

×

UNCOV

6905

    tsdbFSDestroyRefSnapshot(&pSnap->pfSetArray);

×

UNCOV

6907

    taosMemoryFree(pSnap);

×

UNCOV

6909

  tsdbTrace("vgId:%d, untake read snapshot", TD_VID(pTsdb->pVnode));

×

UNCOV

6910

×

UNCOV

6913

int32_t tsdbReaderSetId(void* p, const char* idstr) {

×

UNCOV

6914

  int32_t      code = TSDB_CODE_SUCCESS;

×

UNCOV

6915

  int32_t      lino = 0;

×

UNCOV

6916

  STsdbReader* pReader = (STsdbReader*)p;

×

UNCOV

6918

  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);

×

UNCOV

6920

  taosMemoryFreeClear(pReader->idStr);

×

UNCOV

6921

  pReader->idStr = taosStrdup(idstr);

×

UNCOV

6922

  TSDB_CHECK_NULL(pReader->idStr, code, lino, _end, terrno);

×

UNCOV

6924

  pReader->status.fileIter.pSttBlockReader->mergeTree.idStr = pReader->idStr;

×

UNCOV

6926

_end:

×

UNCOV

6927

  if (code != TSDB_CODE_SUCCESS) {

×

6928

    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));

×

UNCOV

6930

  return code;

×

UNCOV

6933

void tsdbReaderSetCloseFlag(STsdbReader* pReader) { /*pReader->code = TSDB_CODE_TSC_QUERY_CANCELLED;*/ }

×

UNCOV

6935

void tsdbSetFilesetDelimited(STsdbReader* pReader) { pReader->bFilesetDelimited = true; }

×

UNCOV

6937

void tsdbReaderSetNotifyCb(STsdbReader* pReader, TsdReaderNotifyCbFn notifyFn, void* param) {

×

UNCOV

6938

  pReader->notifyFn = notifyFn;

×

UNCOV

6939

  pReader->notifyParam = param;

×

UNCOV

6940

×

taosdata / TDengine / #3565

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

taosdata / TDengine / #3565

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