taosdata/TDengine | Build 4938 | source/libs/executor/src/scanoperator.c | Coveralls

76

bool processBlockWithProbability(const SSampleExecInfo* pInfo) {

493,430,660✔

85

  return true;

493,430,660✔

89

static void switchCtxOrder(SqlFunctionCtx* pCtx, int32_t numOfOutput) {

64,924✔

90

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

64,924✔

93

64,924✔

95

static int32_t overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockInfo, int32_t order, bool* overlap) {

533,407,792✔

96

  int32_t     code = TSDB_CODE_SUCCESS;

533,407,792✔

97

  STimeWindow w = {0};

533,407,792✔

100

  if (pInterval->interval == 0) {

533,469,385✔

101

    *overlap = false;

495,737,894✔

102

    return code;

495,788,032✔

105

  if (order == TSDB_ORDER_ASC) {

37,769,847✔

106

    w = getAlignQueryTimeWindow(pInterval, pBlockInfo->window.skey);

36,631,836✔

107

    if (w.ekey < pBlockInfo->window.skey) {

36,620,310✔

112

    if (w.ekey < pBlockInfo->window.ekey) {

36,628,196✔

113

      *overlap = true;

31,230,083✔

114

      return code;

31,232,328✔

118

      getNextTimeWindow(pInterval, &w, order);

5,395,348✔

119

      if (w.skey > pBlockInfo->window.ekey) {

5,410,549✔

120

        break;

5,145,764✔

123

      if (w.ekey <= pBlockInfo->window.ekey) {

263,486✔

127

      if (TMAX(w.skey, pBlockInfo->window.skey) <= pBlockInfo->window.ekey) {

263,486✔

128

        *overlap = true;

263,486✔

129

        return code;

263,486✔

133

    w = getAlignQueryTimeWindow(pInterval, pBlockInfo->window.ekey);

1,174,303✔

134

    if (w.skey > pBlockInfo->window.ekey) {

1,173,069✔

139

    if (w.skey > pBlockInfo->window.skey) {

1,173,683✔

140

      *overlap = true;

1,010,476✔

141

      return code;

1,010,476✔

145

      getNextTimeWindow(pInterval, &w, order);

163,211✔

146

      if (w.ekey < pBlockInfo->window.skey) {

163,825✔

147

        break;

161,317✔

150

      if (w.skey >= pBlockInfo->window.skey) {

2,508✔

154

      if (pBlockInfo->window.skey <= TMIN(w.ekey, pBlockInfo->window.ekey)) {

2,508✔

155

        *overlap = true;

2,508✔

156

        return code;

2,508✔

161

  *overlap = false;

5,307,081✔

162

  return code;

5,305,371✔

166

static SResultRow* getTableGroupOutputBuf(SOperatorInfo* pOperator, uint64_t groupId, SFilePage** pPage) {

108,530,732✔

167

  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {

108,530,732✔

171

  int64_t buf[2] = {0};

108,539,189✔

172

  SET_RES_WINDOW_KEY((char*)buf, &groupId, sizeof(groupId), groupId);

108,521,685✔

174

  STableScanInfo* pTableScanInfo = pOperator->info;

108,548,324✔

176

  SResultRowPosition* p1 = (SResultRowPosition*)tSimpleHashGet(pTableScanInfo->base.pdInfo.pAggSup->pResultRowHashTable,

108,513,427✔

179

  if (p1 == NULL) {

108,556,363✔

180

    return NULL;

49,874,012✔

183

  *pPage = getBufPage(pTableScanInfo->base.pdInfo.pAggSup->pResultBuf, p1->pageId);

58,682,351✔

184

  if (NULL == *pPage) {

58,667,952✔

188

  return (SResultRow*)((char*)(*pPage) + p1->offset);

58,674,748✔

191

static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint64_t uid) {

11,966,143✔

192

  if (NULL == pTableScanInfo->pIgnoreTables) {

11,966,143✔

193

    int32_t tableNum = taosArrayGetSize(pTableScanInfo->base.pTableListInfo->pTableList);

1,443,906✔

194

    pTableScanInfo->pIgnoreTables =

1,443,906✔

195

        taosHashInit(tableNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);

1,443,906✔

196

    if (NULL == pTableScanInfo->pIgnoreTables) {

1,443,906✔

201

  int32_t tempRes = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,

11,967,334✔

203

  if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {

11,922,372✔

207

  return TSDB_CODE_SUCCESS;

11,922,372✔

210

static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) {

591,129,067✔

211

  STableScanInfo* pTableScanInfo = pOperator->info;

591,129,067✔

212

  int32_t         code = TSDB_CODE_SUCCESS;

591,418,035✔

214

  if (pTableScanInfo->base.pdInfo.pExprSup == NULL) {

591,418,035✔

215

    return TSDB_CODE_SUCCESS;

482,859,851✔

218

  SExprSupp* pSup1 = pTableScanInfo->base.pdInfo.pExprSup;

108,490,029✔

220

  SFilePage*  pPage = NULL;

108,508,342✔

221

  SResultRow* pRow = getTableGroupOutputBuf(pOperator, pBlockInfo->id.groupId, &pPage);

108,476,397✔

223

  if (pRow == NULL) {

108,502,533✔

224

    return TSDB_CODE_SUCCESS;

49,859,994✔

227

  bool notLoadBlock = true;

58,642,539✔

228

  for (int32_t i = 0; i < pSup1->numOfExprs; ++i) {

2,147,483,647✔

229

    int32_t functionId = pSup1->pCtx[i].functionId;

2,147,483,647✔

231

    SResultRowEntryInfo* pEntry = getResultEntryInfo(pRow, i, pTableScanInfo->base.pdInfo.pExprSup->rowEntryInfoOffset);

2,147,483,647✔

233

    EFuncDataRequired reqStatus = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo);

2,147,483,647✔

234

    if (reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD && !pSup1->pCtx[i].skipDynDataCheck) {

2,147,483,647✔

235

      notLoadBlock = false;

46,710,139✔

236

      break;

46,710,139✔

241

  releaseBufPage(pTableScanInfo->base.pdInfo.pAggSup->pResultBuf, pPage);

58,451,886✔

243

  if (notLoadBlock) {

58,672,877✔

244

    *status = FUNC_DATA_REQUIRED_NOT_LOAD;

11,972,054✔

245

    code = insertTableToScanIgnoreList(pTableScanInfo, pBlockInfo->id.uid);

11,972,054✔

248

  return code;

58,636,217✔

251

static int32_t doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg* pColsAgg, int32_t numOfCols,

8,848,029✔

253

  if (pColsAgg == NULL || pFilterInfo == NULL) {

8,848,029✔

258

  return filterRangeExecute(pFilterInfo, pColsAgg, numOfCols, numOfRows, keep);

8,849,470✔

261

static int32_t doLoadBlockSMA(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo,

122,871,805✔

263

  SStorageAPI* pAPI = &pTaskInfo->storageAPI;

122,871,805✔

264

  bool         allColumnsHaveAgg = true;

122,935,905✔

265

  bool         hasNullSMA = false;

122,956,213✔

266

  if (pLoad != NULL) {

122,940,144✔

267

    *pLoad = false;

122,915,469✔

270

  int32_t code = pAPI->tsdReader.tsdReaderRetrieveBlockSMAInfo(pTableScanInfo->dataReader, pBlock, &allColumnsHaveAgg,

122,928,914✔

272

  if (code != TSDB_CODE_SUCCESS) {

122,871,553✔

276

  if (!allColumnsHaveAgg || hasNullSMA) {

122,871,553✔

277

    *pLoad = false;

108,625,857✔

279

    *pLoad = true;

14,245,696✔

282

  return code;

122,863,875✔

285

static int32_t doSetTagColumnData(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo,

621,640,775✔

287

  int32_t    code = 0;

621,640,775✔

288

  SExprSupp* pSup = &pTableScanInfo->pseudoSup;

621,640,775✔

289

  if (pSup->numOfExprs > 0) {

621,885,021✔

290

    code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock, rows,

269,254,307✔

293

    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {

269,083,305✔

294

      if (pTaskInfo->streamInfo.pState) blockDataCleanup(pBlock);

22,262✔

299

  return code;

621,663,786✔

302

bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) {

1,065,568,318✔

303

  SLimit*     pLimit = &pLimitInfo->limit;

1,065,568,318✔

304

  const char* id = GET_TASKID(pTaskInfo);

1,065,654,410✔

306

  if (pLimitInfo->remainOffset > 0) {

1,065,753,630✔

307

    if (pLimitInfo->remainOffset >= pBlock->info.rows) {

4,308,074✔

308

      pLimitInfo->remainOffset -= pBlock->info.rows;

2,345,348✔

309

      blockDataEmpty(pBlock);

2,345,348✔

310

      qDebug("current block ignore due to offset, current:%" PRId64 ", %s", pLimitInfo->remainOffset, id);

2,345,348✔

311

      return false;

2,345,348✔

313

      int32_t code = blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset);

1,962,726✔

314

      if (code != TSDB_CODE_SUCCESS) {

1,962,726✔

319

      pLimitInfo->remainOffset = 0;

1,962,726✔

323

  if (pLimit->limit != -1 && pLimit->limit <= (pLimitInfo->numOfOutputRows + pBlock->info.rows)) {

1,063,411,174✔

325

    int32_t keep = (int32_t)(pLimit->limit - pLimitInfo->numOfOutputRows);

29,266,155✔

326

    blockDataKeepFirstNRows(pBlock, keep);

29,266,502✔

328

    pLimitInfo->numOfOutputRows += pBlock->info.rows;

29,261,246✔

329

    qDebug("output limit %" PRId64 " has reached, %s", pLimit->limit, id);

29,261,596✔

330

    return true;

29,262,806✔

333

  pLimitInfo->numOfOutputRows += pBlock->info.rows;

1,033,956,512✔

334

  return false;

1,034,106,427✔

341

static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableScanInfo, SSDataBlock* pBlock,

620,954,787✔

343

  int32_t        code = TSDB_CODE_SUCCESS;

620,954,787✔

344

  int32_t        lino = 0;

620,954,787✔

345

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

620,954,787✔

346

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

621,137,127✔

347

  bool           loadSMA = false;

621,036,928✔

349

  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;

621,036,928✔

351

  pCost->totalBlocks += 1;

621,151,877✔

352

  pCost->totalRows += pBlock->info.rows;

621,042,500✔

353

  *status = pTableScanInfo->dataBlockLoadFlag;

621,134,791✔

355

  if (pOperator->exprSupp.pFilterInfo != NULL) {

621,021,931✔

356

    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;

87,454,801✔

358

    bool overlap = false;

533,532,822✔

360

        overlapWithTimeWindow(&pTableScanInfo->pdInfo.interval, &pBlock->info, pTableScanInfo->cond.order, &overlap);

533,600,895✔

361

    if (ret != TSDB_CODE_SUCCESS) {

533,102,923✔

364

    if (overlap) {

533,102,923✔

365

      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;

32,489,288✔

369

  SDataBlockInfo* pBlockInfo = &pBlock->info;

620,766,285✔

370

  taosMemoryFreeClear(pBlock->pBlockAgg);

620,829,474✔

372

  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {

620,933,891✔

379

  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {

620,591,702✔

380

    qDebug("%s data block skipped, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64 ", uid:%" PRIu64,

20,905,381✔

383

    code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

20,910,646✔

384

    pCost->skipBlocks += 1;

20,908,591✔

385

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

20,910,501✔

386

    return code;

20,910,776✔

387

  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {

599,672,184✔

388

    pCost->loadBlockStatis += 1;

35,479,115✔

389

    loadSMA = true;  // mark the operation of load sma;

35,476,509✔

390

    bool success = true;

35,476,509✔

391

    code = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo, &success);

35,487,485✔

392

    if (code) {

35,473,464✔

395

      QUERY_CHECK_CODE(code, lino, _end);

1,047✔

398

    if (success) {  // failed to load the block sma data, data block statistics does not exist, load data block instead

35,472,525✔

399

      qDebug("%s data block SMA loaded, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo),

5,394,785✔

401

      code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

5,394,785✔

402

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

5,395,047✔

403

      return code;

5,482,661✔

405

      qDebug("%s failed to load SMA, since not all columns have SMA", GET_TASKID(pTaskInfo));

30,077,740✔

406

      *status = FUNC_DATA_REQUIRED_DATA_LOAD;

30,092,861✔

410

  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {

594,285,348✔

417

  if (pOperator->exprSupp.pFilterInfo != NULL && (!loadSMA)) {

594,278,653✔

418

    bool success = true;

87,453,945✔

419

    code = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo, &success);

87,460,142✔

420

    if (code) {

87,400,404✔

423

      QUERY_CHECK_CODE(code, lino, _end);

7,394✔

426

    if (success) {

87,392,750✔

427

      size_t size = taosArrayGetSize(pBlock->pDataBlock);

8,847,767✔

428

      bool   keep = false;

8,850,780✔

429

      code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);

8,850,780✔

430

      if (code) {

8,849,732✔

436

      if (!keep) {

8,848,029✔

437

        qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,

3,296,657✔

439

        pCost->filterOutBlocks += 1;

3,296,657✔

440

        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;

3,296,657✔

441

        taosMemoryFreeClear(pBlock->pBlockAgg);

3,296,657✔

443

        pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

3,296,657✔

444

        return TSDB_CODE_SUCCESS;

3,296,657✔

450

  taosMemoryFreeClear(pBlock->pBlockAgg);

591,176,126✔

453

  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);

591,043,642✔

454

  if (code) {

591,081,331✔

455

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

8,962✔

459

  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {

591,079,417✔

460

    qDebug("%s data block skipped due to dynamic prune, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,

11,971,743✔

462

    pCost->skipBlocks += 1;

12,002,233✔

463

    pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);

11,973,770✔

465

    STableScanInfo* p1 = pOperator->info;

11,973,770✔

466

    if (taosHashGetSize(p1->pIgnoreTables) == taosArrayGetSize(p1->base.pTableListInfo->pTableList)) {

11,973,770✔

467

      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;

3,257,952✔

469

      *status = FUNC_DATA_REQUIRED_FILTEROUT;

8,715,818✔

471

    return TSDB_CODE_SUCCESS;

11,973,770✔

474

  pCost->totalCheckedRows += pBlock->info.rows;

578,986,226✔

475

  pCost->loadBlocks += 1;

579,308,261✔

477

  SSDataBlock* p = NULL;

579,122,045✔

478

  code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pTableScanInfo->dataReader, &p);

579,133,048✔

479

  if (p == NULL || code != TSDB_CODE_SUCCESS || p != pBlock) {

579,312,689✔

483

  if ((pOperator->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) &&

579,397,921✔

484

      ((STableScanInfo*)pOperator->info)->ignoreTag) {

453,628,978✔

488

    code = doSetTagColumnData(pTableScanInfo, pBlock, pTaskInfo, pBlock->info.rows);

549,636,916✔

489

    if (code) {

549,755,170✔

495

  pCost->totalRows -= pBlock->info.rows;

579,274,547✔

497

  if (pOperator->exprSupp.pFilterInfo != NULL) {

579,246,134✔

498

    code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo, NULL);

84,132,176✔

499

    QUERY_CHECK_CODE(code, lino, _end);

84,092,799✔

501

    int64_t st = taosGetTimestampUs();

83,098,027✔

502

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

83,080,948✔

503

    pTableScanInfo->readRecorder.filterTime += el;

83,080,948✔

505

    if (pBlock->info.rows == 0) {

83,074,895✔

506

      pCost->filterOutBlocks += 1;

15,654,325✔

507

      qDebug("%s data block filter out, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64 ", elapsed time:%.2f ms",

15,660,432✔

510

      qDebug("%s data block filter applied, elapsed time:%.2f ms", GET_TASKID(pTaskInfo), el);

67,387,060✔

514

  bool limitReached = applyLimitOffset(&pTableScanInfo->limitInfo, pBlock, pTaskInfo);

578,197,521✔

515

  if (limitReached) {  // set operator flag is done

578,356,713✔

516

    setOperatorCompleted(pOperator);

2,803,179✔

519

  pCost->totalRows += pBlock->info.rows;

578,442,708✔

521

_end:

579,511,655✔

522

  if (code != TSDB_CODE_SUCCESS) {

579,489,521✔

523

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

1,050,981✔

525

  return code;

579,212,567✔

528

static void prepareForDescendingScan(STableScanBase* pTableScanInfo, SqlFunctionCtx* pCtx, int32_t numOfOutput) {

64,924✔

529

  SET_REVERSE_SCAN_FLAG(pTableScanInfo);

64,924✔

531

  switchCtxOrder(pCtx, numOfOutput);

64,924✔

532

  pTableScanInfo->cond.order = TSDB_ORDER_DESC;

64,924✔

535

64,924✔

603

int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr, SSDataBlock* pBlock,

326,052,233✔

605

  int32_t          code = TSDB_CODE_SUCCESS;

326,052,233✔

606

  int32_t          lino = 0;

326,052,233✔

607

  bool             freeReader = false;

326,052,233✔

608

  LRUHandle*       h = NULL;

326,052,233✔

609

  STableCachedVal  val = {0};

326,052,233✔

610

  SMetaReader      mr = {0};

326,052,233✔

611

  const char*      idStr = pTask->id.str;

326,069,335✔

612

  int32_t          insertRet = TAOS_LRU_STATUS_OK;

326,101,407✔

613

  STableCachedVal* pVal = NULL;

326,101,407✔

616

  if (numOfExpr <= 0) {

326,112,240✔

617

    return TSDB_CODE_SUCCESS;

167,258✔

623

  int32_t backupRows = pBlock->info.rows;

325,944,982✔

624

  pBlock->info.rows = rows;

326,004,011✔

630

  if (pCache == NULL || pCache->pTableMetaEntryCache == NULL) {

325,965,049✔

631

    pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_LOCK, &pHandle->api.metaFn);

325,982,335✔

632

    code = pHandle->api.metaReaderFn.getEntryGetUidCache(&mr, pBlock->info.id.uid);

326,033,543✔

633

    if (code != TSDB_CODE_SUCCESS) {

325,790,091✔

648

    pHandle->api.metaReaderFn.readerReleaseLock(&mr);

325,790,091✔

650

    val.pName = mr.me.name;

325,972,476✔

651

    val.pTags = (STag*)mr.me.ctbEntry.pTags;

325,972,476✔

653

    freeReader = true;

325,972,476✔

695

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

1,094,105,412✔

696

    const SExprInfo* pExpr1 = &pExpr[j];

768,125,518✔

697

    int32_t          dstSlotId = pExpr1->base.resSchema.slotId;

768,125,349✔

699

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotId);

768,336,102✔

700

    colInfoDataCleanup(pColInfoData, pBlock->info.rows);

768,309,468✔

702

    int32_t functionId = pExpr1->pExpr->_function.functionId;

768,250,290✔

705

    if (fmIsScanPseudoColumnFunc(functionId)) {

768,397,844✔

706

      int32_t fType = pExpr1->pExpr->_function.functionType;

90,010,843✔

707

      if (fType == FUNCTION_TYPE_TBNAME) {

90,021,261✔

708

        code = setTbNameColData(pBlock, pColInfoData, functionId, val.pName);

90,021,261✔

709

        QUERY_CHECK_CODE(code, lino, _end);

90,005,861✔

718

      STagVal tagVal = {0};

678,146,239✔

719

      tagVal.cid = pExpr1->base.pParam[0].pCol->colId;

678,088,488✔

720

      const char* p = pHandle->api.metaFn.extractTagVal(val.pTags, pColInfoData->info.type, &tagVal);

678,334,670✔

722

      char* data = NULL;

678,326,263✔

723

      if (pColInfoData->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {

678,326,263✔

724

        data = tTagValToData((const STagVal*)p, false);

672,764,917✔

726

        data = (char*)p;

5,535,488✔

729

      bool isNullVal = (data == NULL) || (pColInfoData->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data));

678,202,436✔

730

      if (isNullVal) {

678,323,173✔

731

        colDataSetNNULL(pColInfoData, 0, pBlock->info.rows);

5,063,404✔

732

      } else if (pColInfoData->info.type != TSDB_DATA_TYPE_JSON) {

673,259,769✔

733

        code = colDataSetNItems(pColInfoData, 0, data, pBlock->info.rows, 1, false);

672,618,092✔

734

        if (IS_VAR_DATA_TYPE(((const STagVal*)p)->type)) {

672,786,108✔

735

          char* tmp = taosMemoryCalloc(1, varDataLen(data) + 1);

274,284,470✔

736

          if (tmp != NULL) {

274,319,102✔

737

            memcpy(tmp, varDataVal(data), varDataLen(data));

274,319,102✔

738

            qDebug("get tag value:%s, cid:%d, table name:%s, uid%" PRId64, tmp, tagVal.cid, val.pName,

274,322,648✔

740

            taosMemoryFree(tmp);

274,357,674✔

742

          taosMemoryFree(data);

274,359,410✔

744

        QUERY_CHECK_CODE(code, lino, _end);

672,677,371✔

746

        for (int32_t i = 0; i < pBlock->info.rows; ++i) {

2,925,260✔

747

          code = colDataSetVal(pColInfoData, i, data, false);

2,451,678✔

748

          QUERY_CHECK_CODE(code, lino, _end);

2,453,176✔

755

  pBlock->info.rows = backupRows;

325,979,894✔

757

_end:

325,997,112✔

759

  if (NULL != pVal) {

325,928,727✔

768

  if (freeReader) {

325,928,727✔

769

    pHandle->api.metaReaderFn.clearReader(&mr);

325,935,759✔

771

  if (code != TSDB_CODE_SUCCESS) {

325,981,904✔

774

  return code;

325,917,306✔

777

int32_t setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId,

90,010,979✔

779

  int32_t                     code = TSDB_CODE_SUCCESS;

90,010,979✔

780

  int32_t                     lino = 0;

90,010,979✔

781

  struct SScalarFuncExecFuncs fpSet = {0};

90,010,979✔

782

  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);

90,012,350✔

783

  QUERY_CHECK_CODE(code, lino, _end);

90,012,638✔

785

  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;

90,012,638✔

786

  char   buf[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};

90,012,638✔

787

  STR_TO_VARSTR(buf, name)

89,999,681✔

789

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, len, 1);

90,026,302✔

791

  code = colInfoDataEnsureCapacity(&infoData, 1, false);

90,005,895✔

792

  QUERY_CHECK_CODE(code, lino, _end);

90,014,092✔

794

  code = colDataSetVal(&infoData, 0, buf, false);

90,014,092✔

795

  QUERY_CHECK_CODE(code, lino, _end);

90,007,617✔

797

  SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData};

90,007,617✔

798

  SScalarParam param = {.columnData = pColInfoData};

90,012,741✔

800

  if (fpSet.process != NULL) {

89,998,728✔

801

    code = fpSet.process(&srcParam, 1, &param);

89,998,728✔

802

    QUERY_CHECK_CODE(code, lino, _end);

90,025,334✔

807

  colDataDestroy(&infoData);

90,025,334✔

809

_end:

90,008,403✔

810

  if (code != TSDB_CODE_SUCCESS) {

90,013,556✔

813

  return code;

90,013,556✔

882

static int32_t initNextGroupScan(STableScanInfo* pInfo, STableKeyInfo** pKeyInfo, int32_t* size) {

188,699,227✔

883

  int32_t code = TSDB_CODE_SUCCESS;

188,699,227✔

884

  int32_t lino = 0;

188,699,227✔

885

  code = tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, pKeyInfo, size);

188,699,227✔

886

  QUERY_CHECK_CODE(code, lino, _end);

188,753,086✔

888

  pInfo->tableStartIndex = TARRAY_ELEM_IDX(pInfo->base.pTableListInfo->pTableList, *pKeyInfo);

188,753,086✔

889

  pInfo->tableEndIndex = (pInfo->tableStartIndex + (*size) - 1);

188,718,988✔

890

  pInfo->pResBlock->info.blankFill = false;

188,700,889✔

891

  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);

188,686,111✔

893

  if (!pInfo->needCountEmptyTable) {

188,818,316✔

894

    pInfo->countState = TABLE_COUNT_STATE_END;

171,464,638✔

896

    pInfo->countState = TABLE_COUNT_STATE_SCAN;

17,253,518✔

899

_end:

188,540,134✔

900

  if (code != TSDB_CODE_SUCCESS) {

188,540,134✔

903

  return code;

188,705,827✔

906

void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {

509,687,599✔

907

  if (pInfo->countState == TABLE_COUNT_STATE_END) {

509,687,599✔

908

    return;

440,290,155✔

910

  if (pInfo->base.pTableListInfo->groupOffset) {

69,423,446✔

911

    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;

220,776✔

913

    int32_t code = taosHashRemove(pInfo->base.pTableListInfo->remainGroups, &groupId, sizeof(groupId));

69,206,885✔

914

    if (code != TSDB_CODE_SUCCESS) {

69,243,246✔

915

      qDebug("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

6,077,717✔

920

static SSDataBlock* getOneRowResultBlock(SExecTaskInfo* pTaskInfo, STableScanBase* pBase, SSDataBlock* pBlock,

45,691,157✔

922

  blockDataEmpty(pBlock);

45,691,157✔

923

  pBlock->info.rows = 1;

45,692,651✔

924

  pBlock->info.id.uid = tbInfo->uid;

45,692,651✔

925

  pBlock->info.id.groupId = tbInfo->groupId;

45,692,153✔

926

  pBlock->info.blankFill = true;

45,692,651✔

929

  int32_t col_num = blockDataGetNumOfCols(pBlock);

45,690,659✔

930

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

188,932,758✔

931

    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);

143,241,045✔

936

  terrno = doSetTagColumnData(pBase, pBlock, pTaskInfo, 1);

45,691,713✔

938

  return pBlock;

45,681,429✔

941

static SSDataBlock* getBlockForEmptyTable(SOperatorInfo* pOperator, const STableKeyInfo* tbInfo) {

43,903,643✔

942

  STableScanInfo* pTableScanInfo = pOperator->info;

43,903,643✔

944

      getOneRowResultBlock(pOperator->pTaskInfo, &pTableScanInfo->base, pTableScanInfo->pResBlock, tbInfo);

43,905,137✔

946

  pOperator->resultInfo.totalRows++;

43,884,245✔

947

  return pBlock;

43,905,733✔

954

static int32_t prepareTableScan(SOperatorInfo* pOperator) {

677,158,658✔

955

  int32_t code = TSDB_CODE_SUCCESS;

677,158,658✔

956

  int32_t lino = 0;

677,158,658✔

958

  qDebug("%s, prepareTableScan start", GET_TASKID(pOperator->pTaskInfo));

677,158,658✔

959

  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;

677,261,005✔

960

  if (NULL != pGetParam && NULL != pGetParam->value &&

677,479,051✔

961

      ((STableScanOperatorParam*)pGetParam->value)->paramType ==

31,230,857✔

962

         NOTIFY_TYPE_SCAN_PARAM &&

1,333,194✔

963

      ((STableScanOperatorParam*)pGetParam->value)->notifyToProcess) {

1,333,194✔

964

    STableScanOperatorParam* pNotify =

1,333,194✔

967

    STableScanInfo* pTableScanInfo = pOperator->info;

1,333,194✔

968

    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

1,333,194✔

969

    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

1,333,194✔

970

    code = pAPI->tsdReader.tsdReaderStepDone(pTableScanInfo->base.dataReader,

1,333,194✔

972

    QUERY_CHECK_CODE(code, lino, _end);

1,333,194✔

974

    if (!pGetParam->reUse) {

1,333,194✔

981

      pGetParam->reUse = false;

1,333,194✔

986

    pOperator->pOperatorGetParam = NULL;

1,333,194✔

989

  qDebug("%s, prepareTableScan end", GET_TASKID(pOperator->pTaskInfo));

677,473,757✔

990

_end:

132,997,830✔

991

  if (code != TSDB_CODE_SUCCESS) {

677,444,674✔

995

  return code;

677,439,655✔

998

static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

639,570,075✔

999

  int32_t         code = TSDB_CODE_SUCCESS;

639,570,075✔

1000

  int32_t         lino = 0;

639,570,075✔

1001

  STableScanInfo* pTableScanInfo = pOperator->info;

639,570,075✔

1002

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

639,660,907✔

1003

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

639,601,494✔

1004

  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;

639,739,583✔

1005

  bool            hasNext = false;

639,438,931✔

1006

  int64_t         st = taosGetTimestampUs();

639,597,550✔

1008

  QRY_PARAM_CHECK(ppRes);

639,597,550✔

1009

  pBlock->info.dataLoad = false;

639,655,544✔

1011

  while (true) {

23,439,621✔

1012

    code = pAPI->tsdReader.tsdNextDataBlock(pTableScanInfo->base.dataReader, &hasNext);

662,666,543✔

1013

    if (code != TSDB_CODE_SUCCESS) {

662,832,058✔

1015

      QUERY_CHECK_CODE(code, lino, _end);

880,861✔

1018

    if (!hasNext) {

662,835,070✔

1019

      break;

169,362,254✔

1022

    if (isTaskKilled(pTaskInfo)) {

493,508,174✔

1023

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);

64,380✔

1024

      code = pTaskInfo->code;

18,004✔

1025

      QUERY_CHECK_CODE(code, lino, _end);

18,004✔

1028

    if (pOperator->status == OP_EXEC_DONE) {

493,822,866✔

1029

      pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);

181,798✔

1030

      break;

181,798✔

1034

    bool processThisBlock = processBlockWithProbability(&pTableScanInfo->sample);

493,544,351✔

1035

    if (!processThisBlock) {

493,453,279✔

1036

      continue;

1,929,141✔

1039

    if (pBlock->info.id.uid) {

493,453,279✔

1040

      pBlock->info.id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);

493,603,257✔

1043

    uint32_t status = 0;

493,675,885✔

1044

    code = loadDataBlock(pOperator, &pTableScanInfo->base, pBlock, &status);

493,709,444✔

1045

    QUERY_CHECK_CODE(code, lino, _end);

493,438,141✔

1047

    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

492,448,800✔

1048

      break;

3,257,952✔

1052

    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {

489,190,848✔

1053

      continue;

23,439,621✔

1056

    pOperator->resultInfo.totalRows = pTableScanInfo->base.readRecorder.totalRows;

465,812,985✔

1057

    pTableScanInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

465,915,034✔

1059

    pOperator->cost.totalCost = pTableScanInfo->base.readRecorder.elapsedTime;

465,888,167✔

1060

    pBlock->info.scanFlag = pTableScanInfo->base.scanFlag;

465,941,175✔

1062

    (*ppRes) = pBlock;

465,965,629✔

1063

    return code;

465,809,299✔

1066

_end:

173,786,285✔

1067

  if (code != TSDB_CODE_SUCCESS) {

173,804,848✔

1068

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

1,033,504✔

1069

    pTaskInfo->code = code;

1,033,504✔

1070

    T_LONG_JMP(pTaskInfo->env, code);

1,007,345✔

1072

  return code;

172,771,344✔

1075

static int32_t doGroupedTableScan(SOperatorInfo* pOperator, SSDataBlock** pBlock) {

686,154,450✔

1076

  int32_t         code = TSDB_CODE_SUCCESS;

686,154,450✔

1077

  int32_t         lino = 0;

686,154,450✔

1078

  STableScanInfo* pTableScanInfo = pOperator->info;

686,154,450✔

1079

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

686,263,276✔

1080

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

686,131,836✔

1082

  QRY_PARAM_CHECK(pBlock);

686,187,673✔

1085

  if (pTableScanInfo->base.dataReader == NULL || pOperator->status == OP_EXEC_DONE) {

686,133,129✔

1086

    return code;

2,671,648✔

1090

  while (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {

842,305,979✔

1091

    SSDataBlock* p = NULL;

589,279,776✔

1092

    code = doTableScanImplNext(pOperator, &p);

589,180,690✔

1093

    QUERY_CHECK_CODE(code, lino, _end);

588,151,800✔

1095

    if (p != NULL) {

588,151,800✔

1096

      markGroupProcessed(pTableScanInfo, p->info.id.groupId);

429,355,869✔

1097

      *pBlock = p;

429,263,168✔

1098

      return code;

429,065,458✔

1101

    pTableScanInfo->scanTimes += 1;

158,795,931✔

1102

    taosHashClear(pTableScanInfo->pIgnoreTables);

158,806,320✔

1104

    if (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {

158,828,623✔

1105

      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);

90,253✔

1106

      pTableScanInfo->base.scanFlag = MAIN_SCAN;

82,745✔

1107

      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;

82,745✔

1108

      qDebug("start to repeat ascending order scan data blocks due to query func required, %s", GET_TASKID(pTaskInfo));

82,745✔

1111

      code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond);

82,745✔

1112

      QUERY_CHECK_CODE(code, lino, _end);

79,295✔

1116

  int32_t total = pTableScanInfo->scanInfo.numOfAsc + pTableScanInfo->scanInfo.numOfDesc;

252,982,414✔

1117

  if (pTableScanInfo->scanTimes < total) {

252,989,621✔

1118

    if (pTableScanInfo->base.cond.order == TSDB_ORDER_ASC) {

50,284,510✔

1119

      prepareForDescendingScan(&pTableScanInfo->base, pOperator->exprSupp.pCtx, 0);

64,924✔

1120

      code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond);

64,924✔

1121

      QUERY_CHECK_CODE(code, lino, _end);

64,924✔

1122

      qDebug("%s start to descending order scan data blocks due to query func required", GET_TASKID(pTaskInfo));

64,924✔

1125

    while (pTableScanInfo->scanTimes < total) {

64,234,889✔

1126

      SSDataBlock* p = NULL;

50,297,315✔

1127

      code = doTableScanImplNext(pOperator, &p);

50,278,530✔

1128

      QUERY_CHECK_CODE(code, lino, _end);

50,293,057✔

1130

      if (p != NULL) {

50,293,057✔

1131

        markGroupProcessed(pTableScanInfo, p->info.id.groupId);

36,361,160✔

1132

        *pBlock = p;

36,351,300✔

1133

        return code;

36,351,451✔

1136

      pTableScanInfo->scanTimes += 1;

13,931,897✔

1137

      taosHashClear(pTableScanInfo->pIgnoreTables);

13,931,659✔

1139

      if (pTableScanInfo->scanTimes < total) {

13,934,177✔

1150

  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {

216,601,321✔

1151

    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;

60,500,503✔

1152

    if (pTableListInfo->groupOffset) {  // group by tbname, group by tag + sort

60,499,577✔

1153

      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {

122,466✔

1154

        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;

5,880✔

1156

            (STableKeyInfo*)tableListGetInfo(pTableScanInfo->base.pTableListInfo, pTableScanInfo->tableStartIndex);

5,880✔

1158

        if (NULL == pStart) {

5,880✔

1162

        *pBlock = getBlockForEmptyTable(pOperator, pStart);

5,880✔

1163

        return code;

5,880✔

1166

      int32_t numOfTables = 0;

60,372,071✔

1167

      code = tableListGetSize(pTableListInfo, &numOfTables);

60,373,067✔

1168

      QUERY_CHECK_CODE(code, lino, _end);

60,376,892✔

1170

      if (pTableScanInfo->tableEndIndex + 1 >= numOfTables) {

60,376,892✔

1172

        void* pIte = taosHashIterate(pTableListInfo->remainGroups, NULL);

59,480,054✔

1173

        if (pIte != NULL) {

59,478,706✔

1174

          size_t        keySize = 0;

43,899,755✔

1175

          uint64_t*     pGroupId = taosHashGetKey(pIte, &keySize);

43,899,755✔

1176

          STableKeyInfo info = {.uid = *(uint64_t*)pIte, .groupId = *pGroupId};

43,894,873✔

1177

          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);

43,897,265✔

1178

          markGroupProcessed(pTableScanInfo, *pGroupId);

43,898,261✔

1179

          *pBlock = getBlockForEmptyTable(pOperator, &info);

43,898,261✔

1181

          return code;

43,894,491✔

1185

    pTableScanInfo->countState = TABLE_COUNT_STATE_END;

16,593,269✔

1188

_end:

156,128,224✔

1189

  if (code != TSDB_CODE_SUCCESS) {

172,691,600✔

1194

  return code;

172,691,600✔

1197

static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {

923,558✔

1198

  STableScanInfo*          pInfo = pOperator->info;

923,558✔

1199

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

923,558✔

1200

  int32_t                  code = 0;

923,558✔

1201

  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;

923,558✔

1202

  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value;

923,558✔

1203

  int32_t                  num = taosArrayGetSize(pParam->pUidList);

923,558✔

1204

  if (num <= 0) {

923,558✔

1209

  qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",

923,558✔

1213

  if (pParam->tableSeq) {

923,558✔

1214

    pListInfo->oneTableForEachGroup = true;

688,809✔

1215

    if (taosArrayGetSize(pListInfo->pTableList) > 0) {

688,809✔

1221

    pListInfo->oneTableForEachGroup = false;

234,749✔

1222

    pListInfo->numOfOuputGroups = 1;

234,749✔

1224

  if (pParam->window.skey == INT64_MAX && pParam->window.ekey == INT64_MIN) {

923,558✔

1227

    pInfo->base.cond.twindows.skey = pParam->window.skey;

684,477✔

1228

    pInfo->base.cond.twindows.ekey = pParam->window.ekey;

684,477✔

1231

  STableKeyInfo info = {.groupId = 0};

923,558✔

1232

  int32_t       tableIdx = 0;

923,558✔

1233

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

8,789,441✔

1234

    uint64_t* pUid = taosArrayGet(pParam->pUidList, i);

7,865,883✔

1235

    if (!pUid) {

7,865,883✔

1240

    if (taosHashPut(pListInfo->map, pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {

7,865,883✔

1241

      if (TSDB_CODE_DUP_KEY == terrno) {

6,604,245✔

1242

        continue;

6,604,245✔

1247

    info.uid = *pUid;

1,261,638✔

1248

    void* p = taosArrayPush(pListInfo->pTableList, &info);

1,261,638✔

1249

    if (p == NULL) {

1,261,638✔

1253

    tableIdx++;

1,261,638✔

1254

    qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));

1,261,638✔

1257

  return code;

923,558✔

1260

static int32_t doInitReader(STableScanInfo* pInfo, SExecTaskInfo* pTaskInfo, SStorageAPI* pAPI, int32_t* pNum,

173,552,210✔

1262

  const char* idStr = GET_TASKID(pTaskInfo);

173,552,210✔

1263

  int32_t     code = initNextGroupScan(pInfo, pList, pNum);

173,601,219✔

1264

  if (code) {

173,311,791✔

1265

    qError("%s failed to init groupScan Info, code:%s at line:%d", idStr, tstrerror(code), __LINE__);

51,680✔

1269

  if (pInfo->base.dataReader != NULL) {

173,260,111✔

1274

  code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, *pList, *pNum, pInfo->pResBlock,

324,683,354✔

1275

                                       (void**)&pInfo->base.dataReader, idStr, &pInfo->pIgnoreTables);

173,453,781✔

1276

  if (code) {

173,507,582✔

1277

    qError("%s failed to open tsdbReader, code:%s at line:%d", idStr, tstrerror(code), __LINE__);

2,170✔

1280

  return code;

173,587,736✔

1283

int compareColIdPair(const void* elem1, const void* elem2) {

314,610,562✔

1284

  SColIdPair* node1 = (SColIdPair*)elem1;

314,610,562✔

1285

  SColIdPair* node2 = (SColIdPair*)elem2;

314,610,562✔

1287

  if (node1->orgColId == node2->orgColId) {

314,610,562✔

1288

    return 0;

106,578✔

1291

  return node1->orgColId < node2->orgColId ? -1 : 1;

314,598,584✔

1294

int compareColIdSlotIdPair(const void* elem1, const void* elem2) {

314,576,033✔

1295

  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;

314,576,033✔

1296

  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;

314,576,033✔

1298

  if (node1->orgColId == node2->orgColId) {

314,576,033✔

1299

    return 0;

106,578✔

1302

  return node1->orgColId < node2->orgColId ? -1 : 1;

314,573,467✔

1305

static bool isNewScanParam(STableScanOperatorParam* pParam) {

41,025,363✔

1306

  return pParam->isNewParam;

41,025,363✔

1309

static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {

20,379,002✔

1310

  int32_t                  code = 0;

20,379,002✔

1311

  int32_t                  lino = 0;

20,379,002✔

1312

  STableScanInfo*          pInfo = pOperator->info;

20,379,002✔

1313

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

20,363,119✔

1314

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

20,371,602✔

1315

  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;

20,373,558✔

1316

  SMetaReader              orgTable = {0};

20,379,526✔

1317

  SMetaReader              superTable = {0};

20,406,387✔

1318

  SSchemaWrapper*          schema = NULL;

20,387,081✔

1319

  SArray*                  pColArray = NULL;

20,387,081✔

1320

  SArray*                  pBlockColArray = NULL;

20,387,081✔

1321

  int32_t                  num = 0;

20,387,081✔

1322

  STableKeyInfo*           pList = NULL;

20,382,884✔

1326

  cleanupQueryTableDataCond(&pInfo->base.cond);

20,388,293✔

1328

  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;

20,395,953✔

1329

  if (pGetParam &&

20,397,834✔

1330

      *(ETableScanGetParamType*)pGetParam->value == DYN_TYPE_SCAN_PARAM) {

4,977,203✔

1331

    STableScanOperatorParam* pParam =

4,977,323✔

1333

    pInfo->pBatchColMap = pParam->pBatchTbInfo;

4,977,019✔

1334

    pParam->pBatchTbInfo = NULL;

4,983,371✔

1335

    pInfo->cachedTimeWindow = pParam->window;

4,951,106✔

1336

    pInfo->currentBatchIdx = 0;

4,963,107✔

1337

    pInfo->lastBatchIdx = -1;

4,965,612✔

1338

    pInfo->cachedTagList = pParam->pTagList;

4,962,583✔

1339

    pParam->pTagList = NULL;

4,961,620✔

1340

    pInfo->cachedGroupId = pParam->groupid;

4,974,304✔

1342

    qDebug("vgId:%d dynamic vtable scan with batch param, total %zd tables to scan, groupid:%" PRIu64 ", %s",

4,965,113✔

1344

    taosHashClear(pInfo->pIgnoreTables);

4,965,113✔

1346

    if (pInfo->base.pdInfo.pExprSup) {

4,971,834✔

1347

      SExprSupp* pSup = pInfo->base.pdInfo.pExprSup;

4,782,982✔

1348

      for (int32_t i = 0; i < pSup->numOfExprs; i++) {

60,702,994✔

1349

        SqlFunctionCtx ctx = pSup->pCtx[i];

55,935,301✔

1350

        ctx.skipDynDataCheck = false;

55,919,533✔

1355

  pOrgTbInfo = taosArrayGet(pInfo->pBatchColMap, pInfo->currentBatchIdx);

20,390,704✔

1356

  QUERY_CHECK_NULL(pOrgTbInfo, code, lino, _return, terrno);

20,411,372✔

1358

  if (pInfo->currentBatchIdx == pInfo->lastBatchIdx) {

20,411,372✔

1359

    isNewTable = false;

12,476,703✔

1361

    isNewTable = true;

7,930,672✔

1362

    pInfo->lastBatchIdx = pInfo->currentBatchIdx;

7,930,672✔

1365

  if (isNewTable) {

20,402,405✔

1366

    pAPI->metaReaderFn.initReader(&orgTable, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

7,926,690✔

1367

    code = pAPI->metaReaderFn.getTableEntryByName(&orgTable, strstr(pOrgTbInfo->tbName, ".") + 1);

7,930,607✔

1368

    pAPI->metaReaderFn.readerReleaseLock(&orgTable);

7,902,434✔

1369

    qDebug("dynamic vtable scan for origin table:%s, %s", pOrgTbInfo->tbName, GET_TASKID(pTaskInfo));

7,915,468✔

1370

    QUERY_CHECK_CODE(code, lino, _return);

7,900,333✔

1371

    switch (orgTable.me.type) {

7,900,333✔

1372

      case TSDB_CHILD_TABLE:

275,962✔

1373

        pAPI->metaReaderFn.initReader(&superTable, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

275,962✔

1374

        code = pAPI->metaReaderFn.getTableEntryByUid(&superTable, orgTable.me.ctbEntry.suid);

275,962✔

1375

        pAPI->metaReaderFn.readerReleaseLock(&superTable);

275,962✔

1376

        QUERY_CHECK_CODE(code, lino, _return);

275,962✔

1377

        schema = &superTable.me.stbEntry.schemaRow;

275,962✔

1378

        break;

275,962✔

1379

      case TSDB_NORMAL_TABLE:

7,631,871✔

1380

        schema = &orgTable.me.ntbEntry.schemaRow;

7,631,871✔

1381

        break;

7,631,871✔

1388

    pListInfo->oneTableForEachGroup = true;

7,907,833✔

1389

    taosHashClear(pListInfo->map);

7,909,395✔

1390

    taosArrayClear(pListInfo->pTableList);

7,938,197✔

1392

    uint64_t      pUid = orgTable.me.uid;

7,936,720✔

1393

    STableKeyInfo info = {.groupId = pInfo->cachedGroupId, .uid = pUid};

7,936,720✔

1394

    int32_t       tableIdx = 0;

7,936,156✔

1395

    code = taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t));

7,936,645✔

1396

    QUERY_CHECK_CODE(code, lino, _return);

7,934,125✔

1397

    QUERY_CHECK_NULL(taosArrayPush(pListInfo->pTableList, &info), code, lino, _return, terrno);

15,866,923✔

1398

    qDebug("add dynamic table scan uid:%" PRIu64 ", %" PRIu64 ", %s", info.uid, info.groupId, GET_TASKID(pTaskInfo));

7,932,798✔

1400

    pColArray = taosArrayInit(schema->nCols, sizeof(SColIdPair));

7,932,798✔

1401

    QUERY_CHECK_NULL(pColArray, code, lino, _return, terrno);

7,929,769✔

1402

    pBlockColArray = taosArrayInit(schema->nCols, sizeof(SColIdSlotIdPair));

7,929,769✔

1403

    QUERY_CHECK_NULL(pBlockColArray, code, lino, _return, terrno);

7,927,773✔

1406

    SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID, .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID};

7,927,773✔

1407

    QUERY_CHECK_NULL(taosArrayPush(pColArray, &tsPair), code, lino, _return, terrno);

7,930,258✔

1409

    for (int32_t i = 0; i < taosArrayGetSize(pOrgTbInfo->colMap); ++i) {

30,489,941✔

1410

      SColIdNameKV* kv = taosArrayGet(pOrgTbInfo->colMap, i);

22,561,829✔

1411

      for (int32_t j = 0; j < schema->nCols; j++) {

179,892,056✔

1412

        if (strcmp(kv->colName, schema->pSchema[j].name) == 0) {

179,706,989✔

1413

          SColIdPair pPair = {.vtbColId = kv->colId, .orgColId = (col_id_t)(schema->pSchema[j].colId)};

22,575,092✔

1414

          QUERY_CHECK_NULL(taosArrayPush(pColArray, &pPair), code, lino, _return, terrno);

22,569,119✔

1415

          qDebug("dynamic vtable scan map col:%s, orgColId:%d, vtbColId:%d, %s", kv->colName, pPair.orgColId,

22,569,119✔

1417

          break;

22,558,311✔

1422

    for (int32_t i = 0; i < taosArrayGetSize(pColArray); i++) {

38,440,218✔

1423

      SColIdPair* pPair = (SColIdPair*)taosArrayGet(pColArray, i);

30,497,535✔

1424

      for (int32_t j = 0; j < taosArrayGetSize(pInfo->base.matchInfo.pList); j++) {

183,969,135✔

1425

        SColMatchItem* pItem = taosArrayGet(pInfo->base.matchInfo.pList, j);

183,717,849✔

1426

        if (pItem->colId == pPair->vtbColId) {

183,717,774✔

1427

          SColIdSlotIdPair colIdSlotIdPair = {.orgColId = pPair->orgColId, .vtbSlotId = pItem->dstSlotId};

30,506,243✔

1428

          QUERY_CHECK_NULL(taosArrayPush(pBlockColArray, &colIdSlotIdPair), code, lino, _return, terrno);

30,514,127✔

1429

          qDebug("dynamic vtable scan block col map orgColId:%d, vtbSlotId:%d, %s", colIdSlotIdPair.orgColId,

30,514,127✔

1431

          break;

30,503,638✔

1436

    taosArraySort(pColArray, compareColIdPair);

7,935,817✔

1437

    taosArraySort(pBlockColArray, compareColIdSlotIdPair);

7,928,347✔

1438

    if (pInfo->pBlockColMap) {

7,932,758✔

1439

      taosArrayDestroy(pInfo->pBlockColMap);

5,482,247✔

1440

      pInfo->pBlockColMap = NULL;

5,476,893✔

1442

    pInfo->pBlockColMap = taosArrayDup(pBlockColArray, NULL);

7,922,993✔

1443

    QUERY_CHECK_NULL(pInfo->pBlockColMap, code, lino, _return, terrno)

7,933,671✔

1446

    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);

7,913,821✔

1447

    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);

7,920,283✔

1449

    if (pInfo->base.pdInfo.pExprSup) {

7,932,139✔

1450

      SExprSupp* pSup = pInfo->base.pdInfo.pExprSup;

7,230,184✔

1451

      for (int32_t i = 0; i < pSup->numOfExprs; i++) {

89,759,984✔

1452

        SqlFunctionCtx* ctx = &pSup->pCtx[i];

82,561,384✔

1453

        bool           needScan = false;

82,560,278✔

1454

        for (int32_t j = 0; j < (fmIsImplicitTsFunc(ctx->functionId) ? ctx->numOfParams - 1 : ctx->numOfParams); j++) {

166,252,848✔

1455

          SFunctParam pParam = ctx->param[j];

83,672,449✔

1456

          for (int32_t k = 0; k < taosArrayGetSize(pColArray); k++) {

401,120,514✔

1457

            SColIdPair* pPair = (SColIdPair*)taosArrayGet(pColArray, k);

336,783,932✔

1458

            if (pParam.pCol && pParam.pCol->colId == pPair->vtbColId) {

337,877,483✔

1459

              needScan |= true;

20,840,330✔

1460

              break;

20,840,330✔

1464

        qDebug("dynamic vtable scan expr funcId:%d, needScan:%d, %s", ctx->functionId, needScan, GET_TASKID(pTaskInfo));

82,572,633✔

1465

        if (!needScan) {

82,638,517✔

1466

          ctx->skipDynDataCheck = true;

61,802,159✔

1468

          ctx->skipDynDataCheck = false;

20,836,358✔

1475

    pColArray = pInfo->lastColArray;

12,475,715✔

1476

    pBlockColArray = pInfo->lastBlockColArray;

12,476,204✔

1479

  code = initQueryTableDataCondWithColArray(&pInfo->base.cond, &pInfo->base.orgCond, &pInfo->base.readHandle, pColArray);

20,409,331✔

1480

  QUERY_CHECK_CODE(code, lino, _return);

20,413,433✔

1482

  if (pInfo->pResBlock) {

20,413,433✔

1483

    blockDataDestroy(pInfo->pResBlock);

15,423,031✔

1484

    pInfo->pResBlock = NULL;

15,421,544✔

1487

  qDebug("dynamic vtable scan isNewTable:%d, order:%d, lastTimeWindow:[%" PRId64 ", %" PRId64 "], "

20,405,474✔

1495

  if (isNewTable) {

20,397,580✔

1496

    if (pInfo->cachedTimeWindow.skey == INT64_MAX && pInfo->cachedTimeWindow.ekey == INT64_MIN) {

7,921,376✔

1497

      pInfo->base.cond.twindows.skey = pInfo->base.orgCond.twindows.skey;

7,200,075✔

1498

      pInfo->base.cond.twindows.ekey = pInfo->base.orgCond.twindows.ekey;

7,204,067✔

1500

      pInfo->base.cond.twindows.skey = pInfo->cachedTimeWindow.skey;

734,698✔

1501

      pInfo->base.cond.twindows.ekey = pInfo->cachedTimeWindow.ekey;

700,488✔

1504

    if (pInfo->base.orgCond.order == TSDB_ORDER_DESC)

12,476,204✔

1505

      pInfo->base.cond.twindows.ekey = pInfo->lastTimeWindow.skey - 1;

1,683,560✔

1507

      pInfo->base.cond.twindows.skey = pInfo->lastTimeWindow.ekey + 1;

10,792,644✔

1511

  pInfo->base.cond.suid = orgTable.me.type == TSDB_CHILD_TABLE ? superTable.me.uid : 0;

20,384,212✔

1512

  pInfo->currentGroupId = 0;

20,396,602✔

1513

  pInfo->ignoreTag = true;

20,370,790✔

1515

  code = createOneDataBlockWithColArray(pInfo->pOrgBlock, pBlockColArray, &pInfo->pResBlock);

20,374,223✔

1516

  QUERY_CHECK_CODE(code, lino, _return);

20,395,389✔

1518

  if (isNewTable) {

20,395,389✔

1519

    if (pInfo->base.dataReader != NULL) {

7,919,684✔

1520

      pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);

5,483,340✔

1522

    pInfo->base.dataReader = NULL;

7,886,731✔

1524

    taosRLockLatch(&pTaskInfo->lock);

7,892,464✔

1525

    code = doInitReader(pInfo, pTaskInfo, pAPI, &num, &pList);

7,919,250✔

1526

    taosRUnLockLatch(&pTaskInfo->lock);

7,870,069✔

1527

    QUERY_CHECK_CODE(code, lino, _return);

7,912,963✔

1529

    pInfo->newReader = true;

7,912,963✔

1530

    if (pInfo->lastColArray) {

7,899,964✔

1531

      taosArrayDestroy(pInfo->lastColArray);

2,945,350✔

1532

      pInfo->lastColArray = NULL;

2,944,362✔

1534

    if (pInfo->lastBlockColArray) {

7,910,388✔

1535

      taosArrayDestroy(pInfo->lastBlockColArray);

2,944,362✔

1536

      pInfo->lastBlockColArray = NULL;

2,943,873✔

1538

    pInfo->lastColArray = pColArray;

7,907,070✔

1539

    pInfo->lastBlockColArray = pBlockColArray;

7,904,485✔

1541

    code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);

12,475,705✔

1542

    QUERY_CHECK_CODE(code, lino, _return);

12,476,693✔

1544

    pAPI->tsdReader.tsdReaderSetDatablock(pInfo->base.dataReader, pInfo->pResBlock);

12,476,693✔

1545

    pInfo->newReader = false;

12,476,703✔

1546

    pInfo->scanTimes = 0;

12,476,703✔

1549

  pOperator->status = OP_OPENED;

20,328,424✔

1551

  if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) {

20,380,639✔

1555

  pInfo->currentGroupId = -1;

20,347,101✔

1556

_return:

20,263,306✔

1557

  if (code) {

20,387,523✔

1560

  pAPI->metaReaderFn.clearReader(&superTable);

20,387,523✔

1561

  pAPI->metaReaderFn.clearReader(&orgTable);

20,361,418✔

1562

  return code;

20,354,342✔

1565

static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {

23,987,186✔

1566

  int32_t                  code = 0;

23,987,186✔

1567

  int32_t                  lino = 0;

23,987,186✔

1568

  STableScanInfo*          pInfo = pOperator->info;

23,987,186✔

1569

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

23,987,186✔

1570

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

23,987,186✔

1571

  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;

23,987,186✔

1572

  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value;

23,987,186✔

1573

  SMetaReader              orgTable = {0};

23,987,186✔

1574

  SMetaReader              superTable = {0};

23,987,186✔

1575

  SSchemaWrapper*          schema = NULL;

23,987,186✔

1576

  SArray*                  pColArray = NULL;

23,987,186✔

1577

  SArray*                  pBlockColArray = NULL;

23,987,186✔

1578

  int32_t                  num = 0;

23,987,186✔

1579

  STableKeyInfo*           pList = NULL;

23,987,186✔

1582

  cleanupQueryTableDataCond(&pInfo->base.cond);

23,987,186✔

1584

  pOrgTbInfo = pParam->pOrgTbInfo;

23,987,186✔

1586

  QUERY_CHECK_NULL(pOrgTbInfo, code, lino, _return, terrno);

23,987,186✔

1588

  pAPI->metaReaderFn.initReader(&orgTable, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

23,987,186✔

1589

  code = pAPI->metaReaderFn.getTableEntryByName(&orgTable, strstr(pOrgTbInfo->tbName, ".") + 1);

23,987,186✔

1590

  pAPI->metaReaderFn.readerReleaseLock(&orgTable);

23,987,186✔

1591

  qDebug("dynamic vtable scan for origin table:%s, %s", pOrgTbInfo->tbName, GET_TASKID(pTaskInfo));

23,987,186✔

1592

  QUERY_CHECK_CODE(code, lino, _return);

23,987,186✔

1593

  switch (orgTable.me.type) {

23,987,186✔

1594

    case TSDB_CHILD_TABLE:

6,303,205✔

1595

      pAPI->metaReaderFn.initReader(&superTable, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

6,303,205✔

1596

      code = pAPI->metaReaderFn.getTableEntryByUid(&superTable, orgTable.me.ctbEntry.suid);

6,303,205✔

1597

      pAPI->metaReaderFn.readerReleaseLock(&superTable);

6,303,205✔

1598

      QUERY_CHECK_CODE(code, lino, _return);

6,303,205✔

1599

      schema = &superTable.me.stbEntry.schemaRow;

6,303,205✔

1600

      break;

6,303,205✔

1601

    case TSDB_NORMAL_TABLE:

17,683,981✔

1602

      schema = &orgTable.me.ntbEntry.schemaRow;

17,683,981✔

1603

      break;

17,683,981✔

1610

  pListInfo->oneTableForEachGroup = true;

23,987,186✔

1611

  taosHashClear(pListInfo->map);

23,987,186✔

1612

  taosArrayClear(pListInfo->pTableList);

23,987,186✔

1614

  uint64_t      pUid = orgTable.me.uid;

23,987,186✔

1615

  STableKeyInfo info = {.groupId = 0, .uid = pUid};

23,987,186✔

1616

  int32_t       tableIdx = 0;

23,987,186✔

1617

  code = taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t));

23,987,186✔

1618

  QUERY_CHECK_CODE(code, lino, _return);

23,987,186✔

1619

  QUERY_CHECK_NULL(taosArrayPush(pListInfo->pTableList, &info), code, lino, _return, terrno);

47,974,372✔

1620

  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));

23,987,186✔

1622

  pColArray = taosArrayInit(schema->nCols, sizeof(SColIdPair));

23,987,186✔

1623

  QUERY_CHECK_NULL(pColArray, code, lino, _return, terrno);

23,987,186✔

1624

  pBlockColArray = taosArrayInit(schema->nCols, sizeof(SColIdSlotIdPair));

23,987,186✔

1625

  QUERY_CHECK_NULL(pBlockColArray, code, lino, _return, terrno);

23,987,186✔

1628

  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,

23,987,186✔

1632

  QUERY_CHECK_NULL(taosArrayPush(pColArray, &tsPair), code, lino, _return, terrno);

23,987,186✔

1634

  for (int32_t i = 0; i < taosArrayGetSize(pOrgTbInfo->colMap); ++i) {

96,220,291✔

1635

    SColIdNameKV* kv = taosArrayGet(pOrgTbInfo->colMap, i);

72,233,105✔

1636

    for (int32_t j = 0; j < schema->nCols; j++) {

610,156,889✔

1637

      if (strcmp(kv->colName, schema->pSchema[j].name) == 0) {

610,156,889✔

1638

        SColIdPair pPair = {.vtbColId = kv->colId,

72,233,105✔

1639

                            .orgColId = (col_id_t)(schema->pSchema[j].colId),

72,233,105✔

1640

                            .type.type = schema->pSchema[j].type,

72,233,105✔

1641

                            .type.bytes = schema->pSchema[j].bytes};

72,233,105✔

1642

        QUERY_CHECK_NULL(taosArrayPush(pColArray, &pPair), code, lino, _return, terrno);

72,233,105✔

1643

        break;

72,233,105✔

1648

  for (int32_t i = 0; i < taosArrayGetSize(pColArray); i++) {

120,206,859✔

1649

    SColIdPair* pPair = (SColIdPair*)taosArrayGet(pColArray, i);

96,220,291✔

1650

    for (int32_t j = 0; j < taosArrayGetSize(pInfo->base.matchInfo.pList); j++) {

607,068,933✔

1651

      SColMatchItem* pItem = taosArrayGet(pInfo->base.matchInfo.pList, j);

607,068,933✔

1652

      if (pItem->colId == pPair->vtbColId) {

607,068,933✔

1653

        if (pItem->dataType.type != pPair->type.type || pItem->dataType.bytes != pPair->type.bytes) {

96,220,291✔

1654

          qError("column type not match for vtable colId:%d, org colId:%d, org table name:%s", pPair->vtbColId,

618✔

1656

          code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;

618✔

1657

          goto _return;

618✔

1659

        SColIdSlotIdPair colIdSlotIdPair = {.orgColId = pPair->orgColId, .vtbSlotId = pItem->dstSlotId};

96,219,673✔

1660

        QUERY_CHECK_NULL(taosArrayPush(pBlockColArray, &colIdSlotIdPair), code, lino, _return, terrno);

96,219,673✔

1661

        break;

96,219,673✔

1666

  taosArraySort(pColArray, compareColIdPair);

23,986,568✔

1667

  taosArraySort(pBlockColArray, compareColIdSlotIdPair);

23,986,568✔

1668

  if (pInfo->pBlockColMap) {

23,986,568✔

1669

    taosArrayDestroy(pInfo->pBlockColMap);

21,538,209✔

1670

    pInfo->pBlockColMap = NULL;

21,538,209✔

1672

  pInfo->pBlockColMap = taosArrayDup(pBlockColArray, NULL);

23,986,568✔

1673

  QUERY_CHECK_NULL(pInfo->pBlockColMap, code, lino, _return, terrno)

23,986,568✔

1675

  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);

23,986,568✔

1676

  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);

23,986,568✔

1678

  code = initQueryTableDataCondWithColArray(&pInfo->base.cond, &pInfo->base.orgCond, &pInfo->base.readHandle, pColArray);

23,986,568✔

1679

  QUERY_CHECK_CODE(code, lino, _return);

23,986,568✔

1681

  if (pInfo->pResBlock) {

23,986,568✔

1682

    blockDataDestroy(pInfo->pResBlock);

17,041,015✔

1683

    pInfo->pResBlock = NULL;

17,041,015✔

1686

  if (isNewScanParam(pParam)) {

23,986,568✔

1687

    if (pParam->window.skey == INT64_MAX && pParam->window.ekey == INT64_MIN) {

6,952,764✔

1688

      pInfo->base.cond.twindows.skey = pInfo->base.orgCond.twindows.skey;

6,952,764✔

1689

      pInfo->base.cond.twindows.ekey = pInfo->base.orgCond.twindows.ekey;

6,952,764✔

1695

    pInfo->base.cond.twindows.skey = pParam->window.ekey + 1;

17,033,804✔

1697

  pInfo->base.cond.suid = orgTable.me.type == TSDB_CHILD_TABLE ? superTable.me.uid : 0;

23,986,568✔

1698

  pInfo->currentGroupId = 0;

23,986,568✔

1699

  pInfo->ignoreTag = true;

23,986,568✔

1701

  code = createOneDataBlockWithColArray(pInfo->pOrgBlock, pBlockColArray, &pInfo->pResBlock);

23,986,568✔

1702

  QUERY_CHECK_CODE(code, lino, _return);

23,986,568✔

1704

  void **reader = taosHashGet(pInfo->readerCache, &pUid, sizeof(uint64_t));

23,986,568✔

1705

  if (reader) {

23,986,568✔

1706

    if (isNewScanParam(pParam)) {

17,038,795✔

1707

      pAPI->tsdReader.tsdReaderClose(*reader);

4,991✔

1708

      pInfo->base.dataReader = NULL;

4,991✔

1710

      code = taosHashRemove(pInfo->readerCache, &pUid, sizeof(uint64_t));

4,991✔

1711

      QUERY_CHECK_CODE(code, lino, _return);

4,991✔

1713

      taosRLockLatch(&pTaskInfo->lock);

4,991✔

1714

      code = doInitReader(pInfo, pTaskInfo, pAPI, &num, &pList);

4,991✔

1715

      taosRUnLockLatch(&pTaskInfo->lock);

4,991✔

1716

      QUERY_CHECK_CODE(code, lino, _return);

4,991✔

1718

      code = taosHashPut(pInfo->readerCache, &pUid, sizeof(uint64_t), &pInfo->base.dataReader, POINTER_BYTES);

4,991✔

1719

      QUERY_CHECK_CODE(code, lino, _return);

4,991✔

1720

      pInfo->newReader = true;

4,991✔

1722

      pInfo->base.dataReader = *reader;

17,033,804✔

1723

      code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);

17,033,804✔

1724

      QUERY_CHECK_CODE(code, lino, _return);

17,033,804✔

1726

      pAPI->tsdReader.tsdReaderSetDatablock(pInfo->base.dataReader, pInfo->pResBlock);

17,033,804✔

1727

      pInfo->newReader = false;

17,033,804✔

1728

      pInfo->scanTimes = 0;

17,033,804✔

1731

    pInfo->base.dataReader = NULL;

6,947,773✔

1733

    taosRLockLatch(&pTaskInfo->lock);

6,947,773✔

1734

    code = doInitReader(pInfo, pTaskInfo, pAPI, &num, &pList);

6,947,773✔

1735

    taosRUnLockLatch(&pTaskInfo->lock);

6,947,773✔

1736

    QUERY_CHECK_CODE(code, lino, _return);

6,947,773✔

1738

    code = taosHashPut(pInfo->readerCache, &pUid, sizeof(uint64_t), &pInfo->base.dataReader, POINTER_BYTES);

6,947,773✔

1739

    QUERY_CHECK_CODE(code, lino, _return);

6,947,773✔

1740

    pInfo->newReader = true;

6,947,773✔

1742

  pOperator->status = OP_OPENED;

23,986,568✔

1744

  if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) {

23,986,568✔

1748

  pInfo->currentGroupId = -1;

23,986,568✔

1749

_return:

23,987,186✔

1750

  if (code) {

23,987,186✔

1751

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

618✔

1753

  taosArrayDestroy(pColArray);

23,987,186✔

1754

  taosArrayDestroy(pBlockColArray);

23,987,186✔

1755

  pAPI->metaReaderFn.clearReader(&superTable);

23,987,186✔

1756

  pAPI->metaReaderFn.clearReader(&orgTable);

23,987,186✔

1757

  return code;

23,987,186✔

1760

static int32_t startNextGroupScan(SOperatorInfo* pOperator, SSDataBlock** pResult) {

169,841,572✔

1761

  int32_t         code = TSDB_CODE_SUCCESS;

169,841,572✔

1762

  int32_t         lino = 0;

169,841,572✔

1763

  STableScanInfo* pInfo = pOperator->info;

169,841,572✔

1764

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

169,873,551✔

1765

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

169,835,483✔

1766

  int32_t         numOfTables = 0;

169,859,331✔

1768

  QRY_PARAM_CHECK(pResult);

169,761,494✔

1770

  code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

169,781,552✔

1771

  QUERY_CHECK_CODE(code, lino, _end);

169,801,988✔

1773

  if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) {

169,801,988✔

1774

    setOperatorCompleted(pOperator);

154,655,152✔

1775

    if (pOperator->dynamicTask) {

154,663,171✔

1776

      taosArrayClear(pInfo->base.pTableListInfo->pTableList);

922,836✔

1777

      taosHashClear(pInfo->base.pTableListInfo->map);

922,836✔

1779

    return code;

154,659,547✔

1783

  pOperator->status = OP_OPENED;

15,074,147✔

1784

  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);

15,166,745✔

1786

  int32_t        num = 0;

15,158,920✔

1787

  STableKeyInfo* pList = NULL;

15,159,908✔

1788

  code = initNextGroupScan(pInfo, &pList, &num);

15,132,836✔

1789

  QUERY_CHECK_CODE(code, lino, _end);

15,183,027✔

1791

  code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num);

15,183,027✔

1792

  QUERY_CHECK_CODE(code, lino, _end);

15,174,924✔

1794

  code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond);

15,174,924✔

1795

  QUERY_CHECK_CODE(code, lino, _end);

15,144,553✔

1796

  pInfo->scanTimes = 0;

15,144,553✔

1798

  code = doGroupedTableScan(pOperator, pResult);

15,151,306✔

1799

  QUERY_CHECK_CODE(code, lino, _end);

15,208,709✔

1801

  if (*pResult != NULL) {

15,208,709✔

1802

    if (pOperator->dynamicTask) {

12,379,161✔

1803

      (*pResult)->info.id.groupId = (*pResult)->info.id.uid;

12,143,034✔

1805

    return code;

12,379,161✔

1808

_end:

2,829,124✔

1809

  if (code != TSDB_CODE_SUCCESS) {

2,831,015✔

1813

  return code;

2,832,068✔

1816

static int32_t groupSeqTableScan(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {

630,089,370✔

1817

  int32_t         code = TSDB_CODE_SUCCESS;

630,089,370✔

1818

  int32_t         lino = 0;

630,089,370✔

1819

  STableScanInfo* pInfo = pOperator->info;

630,089,370✔

1820

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

630,018,664✔

1821

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

630,021,366✔

1822

  int32_t         num = 0;

630,030,815✔

1823

  STableKeyInfo*  pList = NULL;

629,943,687✔

1824

  SSDataBlock*    pResult = NULL;

630,088,852✔

1825

  const char*     idStr = GET_TASKID(pTaskInfo);

630,133,944✔

1827

  QRY_PARAM_CHECK(pResBlock);

630,052,028✔

1829

  if (pInfo->currentGroupId == -1) {

630,063,871✔

1830

    if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) {

158,739,207✔

1835

    taosRLockLatch(&pTaskInfo->lock);

158,682,632✔

1836

    code = doInitReader(pInfo, pTaskInfo, pAPI, &num, &pList);

158,742,551✔

1837

    taosRUnLockLatch(&pTaskInfo->lock);

158,729,645✔

1838

    QUERY_CHECK_CODE(code, lino, _end);

158,917,334✔

1840

    if (pInfo->filesetDelimited) {

158,915,164✔

1841

      pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);

235,841✔

1844

    if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) {

158,917,837✔

1849

  code = doGroupedTableScan(pOperator, &pResult);

630,098,701✔

1850

  QUERY_CHECK_CODE(code, lino, _end);

628,744,355✔

1852

  if (pResult != NULL) {

628,744,355✔

1853

    if (pOperator->dynamicTask) {

474,154,287✔

1854

      pResult->info.id.groupId = pResult->info.id.uid;

1,969,080✔

1857

    *pResBlock = pResult;

474,157,127✔

1858

    return code;

473,937,856✔

1862

    code = startNextGroupScan(pOperator, &pResult);

154,654,062✔

1863

    QUERY_CHECK_CODE(code, lino, _end);

154,974,336✔

1865

    if (pResult || pOperator->status == OP_EXEC_DONE) {

154,974,336✔

1866

      *pResBlock = pResult;

154,904,217✔

1867

      return code;

154,899,288✔

1871

_end:

2,170✔

1872

  if (code != TSDB_CODE_SUCCESS) {

2,170✔

1873

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

2,170✔

1874

    pTaskInfo->code = code;

2,170✔

1877

  return code;

2,170✔

1880

static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {

23,986,568✔

1881

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

23,986,568✔

1884

static int32_t doStbJoinDynamicTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

923,558✔

1885

  int32_t                  code = TSDB_CODE_SUCCESS;

923,558✔

1886

  int32_t                  lino = 0;

923,558✔

1887

  STableScanInfo*          pInfo = pOperator->info;

923,558✔

1888

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

923,558✔

1889

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

923,558✔

1890

  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value;

923,558✔

1892

  code = createTableListInfoFromParam(pOperator);

923,558✔

1893

  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);

923,558✔

1894

  pOperator->pOperatorGetParam = NULL;

923,558✔

1895

  QUERY_CHECK_CODE(code, lino, _end);

923,558✔

1897

  if (pOperator->status == OP_EXEC_DONE) {

923,558✔

1898

    pInfo->currentGroupId = -1;

22,497✔

1899

    pOperator->status = OP_OPENED;

22,497✔

1900

    SSDataBlock* result = NULL;

22,497✔

1903

      code = startNextGroupScan(pOperator, &result);

22,497✔

1904

      QUERY_CHECK_CODE(code, lino, _end);

22,497✔

1906

      if (result || pOperator->status == OP_EXEC_DONE) {

22,497✔

1907

        (*ppRes) = result;

22,497✔

1908

        return code;

22,497✔

1912

_end:

901,061✔

1913

  if (code) {

901,061✔

1916

  return code;

901,061✔

1919

static int32_t doVstbSingleDynamicTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

23,987,186✔

1920

  int32_t                  code = TSDB_CODE_SUCCESS;

23,987,186✔

1921

  int32_t                  lino = 0;

23,987,186✔

1922

  STableScanInfo*          pInfo = pOperator->info;

23,987,186✔

1923

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

23,987,186✔

1924

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

23,987,186✔

1925

  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value;

23,987,186✔

1927

  QRY_PARAM_CHECK(ppRes);

23,987,186✔

1928

  qTrace("%s call", __FUNCTION__);

23,987,186✔

1930

  code = createVTableScanInfoFromParam(pOperator);

23,987,186✔

1931

  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);

23,987,186✔

1932

  pOperator->pOperatorGetParam = NULL;

23,987,186✔

1934

  QUERY_CHECK_CODE(code, lino, _end);

23,987,186✔

1936

  SSDataBlock* result = NULL;

23,986,568✔

1937

  if (isEmptyQueryTimeWindow(&pInfo->base.cond.twindows) && pInfo->base.cond.type == TIMEWINDOW_RANGE_CONTAINED) {

23,986,568✔

1938

    (*ppRes) = result;

17,968✔

1939

    return code;

17,968✔

1942

  if (pInfo->newReader) {

23,968,600✔

1943

    code = startNextGroupScan(pOperator, &result);

6,952,764✔

1944

    QUERY_CHECK_CODE(code, lino, _end);

6,952,764✔

1946

    code = doGroupedTableScan(pOperator, &result);

17,015,836✔

1947

    QUERY_CHECK_CODE(code, lino, _end);

17,015,836✔

1950

  if (result) {

23,968,600✔

1951

    SSDataBlock* res = NULL;

17,042,684✔

1952

    pAPI->tsdReader.tsdReaderSetDatablock(pInfo->base.dataReader, NULL);

17,042,684✔

1953

    pInfo->lastTimeWindow.skey = result->info.window.skey;

17,042,684✔

1954

    pInfo->lastTimeWindow.ekey = result->info.window.ekey;

17,042,684✔

1955

    code = createOneDataBlockWithTwoBlock(result, pInfo->pOrgBlock, pInfo->pBlockColMap, &res);

17,042,684✔

1956

    QUERY_CHECK_CODE(code, lino, _end);

17,042,684✔

1958

    pInfo->pResBlock = res;

17,042,684✔

1959

    blockDataDestroy(result);

17,042,684✔

1960

    (*ppRes) = res;

17,042,684✔

1962

    STableKeyInfo *keyInfo = taosArrayGet(pInfo->base.pTableListInfo->pTableList, 0);

6,925,916✔

1963

    QUERY_CHECK_NULL(keyInfo, code, lino, _end, terrno)

6,925,916✔

1965

    blockDataDestroy(pInfo->pResBlock);

6,925,916✔

1966

    pInfo->pResBlock = NULL;

6,925,916✔

1968

    void** reader = taosHashGet(pInfo->readerCache, &keyInfo->uid, sizeof(uint64_t));

6,925,916✔

1969

    if (reader) {

6,925,916✔

1970

      if (*reader == pInfo->base.dataReader) {

6,925,916✔

1971

        pAPI->tsdReader.tsdReaderSetDatablock(pInfo->base.dataReader, NULL);

6,925,916✔

1972

        pInfo->base.dataReader = NULL;

6,925,916✔

1974

      if (pAPI->tsdReader.tsdReaderClose) {

6,925,916✔

1975

        pAPI->tsdReader.tsdReaderClose(*reader);

6,925,916✔

1979

    code = taosHashRemove(pInfo->readerCache, &keyInfo->uid, sizeof(uint64_t));

6,925,916✔

1980

    QUERY_CHECK_CODE(code, lino, _end);

6,925,916✔

1982

_end:

23,969,218✔

1983

  if (code) {

23,969,218✔

1984

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

618✔

1986

  return code;

23,969,218✔

1989

static int32_t setTagValFromTagList(SOperatorInfo* pOperator, SSDataBlock* pRes) {

3,613,118✔

1990

  int32_t                  code = TSDB_CODE_SUCCESS;

3,613,118✔

1991

  int32_t                  lino = 0;

3,613,118✔

1992

  STableScanInfo*          pInfo = pOperator->info;

3,613,118✔

1993

  int32_t                  index = 0;

3,613,118✔

1994

  char*                    tagVal = NULL;

3,613,118✔

1996

  for (int32_t i = taosArrayGetSize(pRes->pDataBlock) - taosArrayGetSize(pInfo->cachedTagList); i < taosArrayGetSize(pRes->pDataBlock); i++) {

25,280,764✔

1997

    SColumnInfoData* pTagCol = taosArrayGet(pRes->pDataBlock, i);

21,667,646✔

1998

    STagVal*         pTagVal = taosArrayGet(pInfo->cachedTagList, index);

21,667,646✔

2000

    QUERY_CHECK_NULL(pTagVal, code, lino, _end, terrno);

21,667,646✔

2001

    QUERY_CHECK_NULL(pTagCol, code, lino, _end, terrno);

21,667,646✔

2003

    for(int32_t j = 0; j < pRes->info.rows; j++) {

2,147,483,647✔

2004

      if (IS_VAR_DATA_TYPE(pTagVal->type)) {

2,147,483,647✔

2005

        tagVal = taosMemoryMalloc(pTagVal->nData + VARSTR_HEADER_SIZE + 1);

2,147,483,647✔

2006

        QUERY_CHECK_NULL(tagVal, code, lino, _end, terrno);

2,147,483,647✔

2008

        varDataSetLen(tagVal, pTagVal->nData);

2,147,483,647✔

2009

        memcpy(tagVal + VARSTR_HEADER_SIZE, pTagVal->pData, pTagVal->nData);

2,147,483,647✔

2010

        code = colDataSetVal(pTagCol, j, tagVal, false);

2,147,483,647✔

2011

        QUERY_CHECK_CODE(code, lino, _end);

2,147,483,647✔

2012

        taosMemoryFreeClear(tagVal);

2,147,483,647✔

2014

        code = colDataSetVal(pTagCol, j, (const char*)&pTagVal->i64, false);

2,147,483,647✔

2015

        QUERY_CHECK_CODE(code, lino, _end);

2,147,483,647✔

2018

    index++;

21,667,646✔

2020

  return code;

3,613,118✔

2027

static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {

4,988,436✔

2028

  if (pInfo->pBatchColMap) {

4,988,436✔

2029

    for (int32_t i = 0; i < taosArrayGetSize(pInfo->pBatchColMap); i++) {

12,920,286✔

2030

      SOrgTbInfo* pOrgTbInfo = (SOrgTbInfo*)taosArrayGet(pInfo->pBatchColMap, i);

7,934,764✔

2031

      taosArrayDestroy(pOrgTbInfo->colMap);

7,932,818✔

2033

    taosArrayDestroy(pInfo->pBatchColMap);

4,987,468✔

2034

    pInfo->pBatchColMap = NULL;

4,983,556✔

2036

  if (pInfo->cachedTagList) {

4,988,446✔

2037

    for (int32_t i = 0; i < taosArrayGetSize(pInfo->cachedTagList); i++) {

15,646,304✔

2038

      STagVal* pTagVal = (STagVal*)taosArrayGet(pInfo->cachedTagList, i);

13,332,322✔

2039

      if (IS_VAR_DATA_TYPE(pTagVal->type)) {

13,332,322✔

2040

        taosMemoryFreeClear(pTagVal->pData);

5,851,905✔

2043

    taosArrayDestroy(pInfo->cachedTagList);

2,313,004✔

2044

    pInfo->cachedTagList = NULL;

2,310,070✔

2046

  if (pInfo->lastColArray) {

4,983,057✔

2047

    taosArrayDestroy(pInfo->lastColArray);

4,987,957✔

2048

    pInfo->lastColArray = NULL;

4,986,490✔

2050

  if (pInfo->lastBlockColArray) {

4,985,492✔

2051

    taosArrayDestroy(pInfo->lastBlockColArray);

4,987,957✔

2052

    pInfo->lastBlockColArray = NULL;

4,983,556✔

2055

  blockDataDestroy(pInfo->pResBlock);

4,983,057✔

2056

  pInfo->pResBlock = NULL;

4,989,913✔

2057

4,989,913✔

2059

static int32_t doVstbBatchDynamicTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

17,446,686✔

2060

  int32_t                  code = TSDB_CODE_SUCCESS;

17,446,686✔

2061

  int32_t                  lino = 0;

17,446,686✔

2062

  STableScanInfo*          pInfo = pOperator->info;

17,446,686✔

2063

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

17,448,238✔

2064

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

17,445,643✔

2065

  SSDataBlock*             result = NULL;

17,447,874✔

2067

  QRY_PARAM_CHECK(ppRes);

17,447,629✔

2068

  qTrace("%s call", __FUNCTION__);

17,457,235✔

2070

  while (!result) {

32,877,850✔

2071

    code = createVTableScanInfoFromBatchParam(pOperator);

20,403,612✔

2072

    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);

20,348,010✔

2073

    pOperator->pOperatorGetParam = NULL;

20,346,016✔

2074

    QUERY_CHECK_CODE(code, lino, _end);

20,374,268✔

2076

    if (pInfo->newReader) {

20,374,268✔

2077

      code = startNextGroupScan(pOperator, &result);

7,890,798✔

2078

      QUERY_CHECK_CODE(code, lino, _end);

7,928,312✔

2080

      code = doGroupedTableScan(pOperator, &result);

12,483,440✔

2081

      QUERY_CHECK_CODE(code, lino, _end);

12,475,216✔

2083

    if (!result) {

20,403,528✔

2084

      qDebug("%s, finished batch scan for current table, switch to next table, idx:%d,  %s",

7,929,055✔

2086

      pInfo->currentBatchIdx++;

7,929,055✔

2087

      if (pInfo->currentBatchIdx >= taosArrayGetSize(pInfo->pBatchColMap)) {

7,930,088✔

2089

        break;

4,988,446✔

2094

  if (result) {

17,462,684✔

2095

    SSDataBlock* res = NULL;

12,475,715✔

2096

    pAPI->tsdReader.tsdReaderSetDatablock(pInfo->base.dataReader, NULL);

12,476,204✔

2097

    pInfo->lastTimeWindow.skey = result->info.window.skey;

12,473,260✔

2098

    pInfo->lastTimeWindow.ekey = result->info.window.ekey;

12,473,270✔

2100

    code = createOneDataBlockWithTwoBlock(result, pInfo->pOrgBlock, pInfo->pBlockColMap, &res);

12,475,151✔

2101

    QUERY_CHECK_CODE(code, lino, _end);

12,476,693✔

2103

    if (pInfo->cachedTagList) {

12,476,693✔

2104

      code = setTagValFromTagList(pOperator, res);

3,613,118✔

2105

      QUERY_CHECK_CODE(code, lino, _end);

3,613,118✔

2108

    res->info.id.groupId = pInfo->cachedGroupId;

12,476,693✔

2109

    pInfo->pResBlock = res;

12,477,192✔

2110

    blockDataDestroy(result);

12,477,192✔

2111

    (*ppRes) = res;

12,475,705✔

2113

    printDataBlock(res, __func__, pTaskInfo->id.str, pTaskInfo->id.queryId);

12,475,705✔

2115

    clearVstbBatchDynamicTableScanInfo(pInfo);

4,986,969✔

2116

    setOperatorCompleted(pOperator);

4,987,957✔

2119

_end:

17,464,640✔

2120

  return code;

17,465,638✔

2123

static int32_t doDynamicTableScanNext(SOperatorInfo* pOperator, ETableScanDynType type, SSDataBlock** ppRes) {

42,373,293✔

2124

  int32_t                  code = TSDB_CODE_SUCCESS;

42,373,293✔

2125

  int32_t                  lino = 0;

42,373,293✔

2126

  STableScanInfo*          pInfo = pOperator->info;

42,373,293✔

2127

  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;

42,377,310✔

2128

  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;

42,374,356✔

2130

  QRY_PARAM_CHECK(ppRes);

42,368,947✔

2131

  qTrace("%s call", __FUNCTION__);

42,365,938✔

2133

  pOperator->dynamicTask = true;

42,365,938✔

2135

  switch (type) {

42,370,434✔

2136

    case DYN_TYPE_VSTB_WIN_SCAN:

923,558✔

2138

      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);

923,558✔

2139

      QUERY_CHECK_CODE(code, lino, _end);

923,558✔

2140

      break;

923,558✔

2142

    case DYN_TYPE_VSTB_SINGLE_SCAN: {

23,987,186✔

2143

      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);

23,987,186✔

2144

      QUERY_CHECK_CODE(code, lino, _end);

23,987,186✔

2145

      break;

23,986,568✔

2147

    case DYN_TYPE_VSTB_BATCH_SCAN:

17,459,690✔

2148

      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);

17,459,690✔

2149

      QUERY_CHECK_CODE(code, lino, _end);

17,463,153✔

2150

      break;

17,463,153✔

2157

_end:

42,373,897✔

2158

  return code;

42,373,897✔

2161

int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

677,247,900✔

2162

  int32_t         code = TSDB_CODE_SUCCESS;

677,247,900✔

2163

  int32_t         lino = 0;

677,247,900✔

2164

  STableScanInfo* pInfo = pOperator->info;

677,247,900✔

2165

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

677,356,820✔

2166

  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;

677,332,484✔

2167

  QRY_PARAM_CHECK(ppRes);

677,342,845✔

2168

  qTrace("%s call", __FUNCTION__);

677,374,647✔

2170

  code = pOperator->fpSet._openFn(pOperator);

677,374,647✔

2171

  QUERY_CHECK_CODE(code, lino, _end);

677,463,676✔

2173

  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;

677,463,676✔

2174

  if (pGetParam || pInfo->pBatchColMap) {

677,481,999✔

2175

    ETableScanDynType type = pGetParam ?

42,364,496✔

2176

      ((STableScanOperatorParam*)pGetParam->value)->dynType :

42,372,814✔

2179

    code = doDynamicTableScanNext(pOperator, type, ppRes);

42,364,496✔

2180

    QUERY_CHECK_CODE(code, lino, _end);

42,373,897✔

2182

    if (*ppRes != NULL || (type != DYN_TYPE_STB_JOIN && type != DYN_TYPE_VSTB_WIN_SCAN)) {

42,373,279✔

2183

      return code;

41,476,150✔

2188

  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {

635,973,127✔

2189

    int32_t       numOfTables = 0;

5,922,508✔

2190

    STableKeyInfo tInfo = {0};

5,922,508✔

2191

    pInfo->countState = TABLE_COUNT_STATE_END;

5,922,508✔

2193

    while (1) {

5,526,502✔

2194

      SSDataBlock* result = NULL;

11,449,010✔

2195

      code = doGroupedTableScan(pOperator, &result);

11,447,164✔

2196

      QUERY_CHECK_CODE(code, lino, _end);

11,439,225✔

2198

      if (result || (pOperator->status == OP_EXEC_DONE) || isTaskKilled(pTaskInfo)) {

11,439,225✔

2199

        (*ppRes) = result;

5,866,197✔

2200

        return code;

5,878,522✔

2204

      pInfo->currentTable++;

5,573,275✔

2206

      taosRLockLatch(&pTaskInfo->lock);

5,564,971✔

2207

      numOfTables = 0;

5,572,380✔

2208

      code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

5,572,380✔

2209

      if (code != TSDB_CODE_SUCCESS) {

5,566,813✔

2214

      if (pInfo->currentTable >= numOfTables) {

5,566,813✔

2215

        qDebug("all table checked in table list, total:%d, return NULL, %s", numOfTables, GET_TASKID(pTaskInfo));

42,451✔

2216

        taosRUnLockLatch(&pTaskInfo->lock);

42,451✔

2217

        (*ppRes) = NULL;

42,451✔

2218

        return code;

42,451✔

2221

      STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->currentTable);

5,515,766✔

2222

      if (!tmp) {

5,529,266✔

2228

      tInfo = *tmp;

5,529,266✔

2229

      taosRUnLockLatch(&pTaskInfo->lock);

5,519,449✔

2231

      code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, &tInfo, 1);

5,532,056✔

2232

      QUERY_CHECK_CODE(code, lino, _end);

5,525,911✔

2233

      qDebug("set uid:%" PRIu64 " into scanner, total tables:%d, index:%d/%d %s", tInfo.uid, numOfTables,

5,525,911✔

2236

      code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond);

5,532,636✔

2237

      QUERY_CHECK_CODE(code, lino, _end);

5,517,925✔

2238

      pInfo->scanTimes = 0;

5,517,925✔

2241

    code = groupSeqTableScan(pOperator, ppRes);

629,995,466✔

2242

    QUERY_CHECK_CODE(code, lino, _end);

628,868,742✔

2245

_end:

628,866,572✔

2246

  if (code != TSDB_CODE_SUCCESS) {

628,910,451✔

2247

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

2,788✔

2248

    pTaskInfo->code = code;

2,788✔

2249

    T_LONG_JMP(pTaskInfo->env, code);

2,788✔

2252

  return code;

628,907,663✔

2255

static int32_t getTableScannerExecInfo(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {

10,981,474✔

2256

  SFileBlockLoadRecorder* pRecorder = taosMemoryCalloc(1, sizeof(SFileBlockLoadRecorder));

10,981,474✔

2257

  if (!pRecorder) {

11,011,953✔

2260

  STableScanInfo* pTableScanInfo = pOptr->info;

11,011,953✔

2261

  *pRecorder = pTableScanInfo->base.readRecorder;

11,011,953✔

2262

  *pOptrExplain = pRecorder;

11,011,953✔

2263

  *len = sizeof(SFileBlockLoadRecorder);

11,011,953✔

2264

  return 0;

11,011,953✔

2267

static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) {

196,904,875✔

2268

  cleanupQueryTableDataCond(&pBase->cond);

196,904,875✔

2269

  cleanupQueryTableDataCond(&pBase->orgCond);

196,902,124✔

2271

  if (pAPI->tsdReaderClose) {

196,922,849✔

2272

    pAPI->tsdReaderClose(pBase->dataReader);

196,932,228✔

2274

  pBase->dataReader = NULL;

196,874,869✔

2276

  if (pBase->matchInfo.pList != NULL) {

196,889,966✔

2277

    taosArrayDestroy(pBase->matchInfo.pList);

196,911,281✔

2280

  tableListDestroy(pBase->pTableListInfo);

196,833,025✔

2281

  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);

196,974,269✔

2282

  cleanupExprSupp(&pBase->pseudoSup);

196,889,939✔

2283

196,951,685✔

2285

static void cleanReaderForVTable(STableScanInfo* pInfo){

6,028,140✔

2286

  if (pInfo != NULL && pInfo->base.readerAPI.tsdReaderClose) {

6,028,140✔

2287

    void *pIter = taosHashIterate(pInfo->readerCache, NULL);

6,027,314✔

2288

    while (pIter != NULL) {

6,049,498✔

2289

      void **reader = pIter;

21,857✔

2290

      if (*reader) {

21,857✔

2291

        if (*reader == pInfo->base.dataReader) {

21,857✔

2292

          pInfo->base.dataReader = NULL;

19,637✔

2294

        pInfo->base.readerAPI.tsdReaderClose(*reader);

21,857✔

2296

      pIter = taosHashIterate(pInfo->readerCache, pIter);

21,857✔

2299

6,030,096✔

2301

static void destroyTableScanOperatorInfo(void* param) {

171,675,468✔

2302

  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;

171,675,468✔

2303

  blockDataDestroy(pTableScanInfo->pResBlock);

171,675,468✔

2304

  blockDataDestroy(pTableScanInfo->pOrgBlock);

171,698,196✔

2305

  taosHashCleanup(pTableScanInfo->pIgnoreTables);

171,718,484✔

2306

  if (pTableScanInfo->virtualStableScan && pTableScanInfo->readerCache) {

171,654,618✔

2307

    cleanReaderForVTable(pTableScanInfo);

6,026,663✔

2308

    taosHashCleanup(pTableScanInfo->readerCache);

6,029,195✔

2310

  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);

171,661,234✔

2311

  taosArrayDestroy(pTableScanInfo->pBlockColMap);

171,656,278✔

2312

  taosMemoryFreeClear(param);

171,704,058✔

2313

171,646,998✔

2315

static void resetClolumnReserve(SSDataBlock* pBlock, int32_t dataRequireFlag) {

171,442,122✔

2316

  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {

171,442,122✔

2317

    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);

8,181,735✔

2318

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

20,286,057✔

2319

      SColumnInfoData* pCol = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);

12,113,327✔

2320

      if (pCol) {

12,111,217✔

2321

        pCol->info.noData = true;

12,113,983✔

2325

171,433,117✔

2327

static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {

258,582✔

2328

  int32_t         code = TSDB_CODE_SUCCESS;

258,582✔

2329

  STableScanInfo*   pInfo = pOper->info;

258,582✔

2330

  pOper->status = OP_NOT_OPENED;

258,582✔

2332

  pInfo->scanTimes = 0;

258,582✔

2333

  pInfo->currentGroupId = -1;

258,582✔

2334

  pInfo->tableEndIndex = -1;

258,582✔

2335

  pInfo->tableStartIndex = 0;

258,582✔

2336

  pInfo->currentTable = 0;

258,582✔

2337

  pInfo->scanMode = 0;

258,582✔

2338

  pInfo->countState = 0;

258,582✔

2339

  pInfo->base.scanFlag = (pInfo->scanInfo.numOfAsc > 1) ? PRE_SCAN : MAIN_SCAN;

258,582✔

2341

  if (!pInfo->virtualStableScan) {

258,582✔

2347

    if (pInfo->base.readerAPI.tsdReaderClose) {

91,823✔

2348

      pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);

91,823✔

2350

    pInfo->base.dataReader = NULL;

91,823✔

2352

  tableListDestroy(pInfo->base.pTableListInfo);

258,582✔

2353

  pInfo->base.pTableListInfo = tableListCreate();

258,582✔

2354

  if (!pInfo->base.pTableListInfo) {

258,582✔

2358

  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;

258,582✔

2360

  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;

258,582✔

2361

  if (!pTableScanNode->scan.node.dynamicOp) {

258,582✔

2362

    code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,

180,951✔

2364

                                    pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);

180,951✔

2365

    if (code) {

90,855✔

2371

  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->base.limitInfo);

258,582✔

2372

  cleanupQueryTableDataCond(&pInfo->base.cond);

258,582✔

2373

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, true);

258,582✔

2374

  if (code) {

258,403✔

2378

  if (pTableScanNode->scan.node.dynamicOp && pTableScanNode->scan.virtualStableScan) {

258,403✔

2379

    cleanupQueryTableDataCond(&pInfo->base.orgCond);

166,759✔

2380

    memcpy(&pInfo->base.orgCond, &pInfo->base.cond, sizeof(SQueryTableDataCond));

166,759✔

2381

    memset(&pInfo->base.cond, 0, sizeof(SQueryTableDataCond));

166,759✔

2384

  pOper->resultInfo.totalRows = 0;

258,403✔

2385

  blockDataEmpty(pInfo->pResBlock);

258,403✔

2386

  blockDataEmpty(pInfo->pOrgBlock);

258,403✔

2387

  taosHashClear(pInfo->pIgnoreTables);

258,582✔

2388

  taosArrayDestroy(pInfo->pBlockColMap);

258,582✔

2389

  pInfo->pBlockColMap = NULL;

258,582✔

2390

  return code;

258,582✔

2393

int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,

171,663,278✔

2396

  QRY_PARAM_CHECK(pOptrInfo);

171,663,278✔

2398

  int32_t         code = TSDB_CODE_SUCCESS;

171,676,135✔

2399

  int32_t         lino = 0;

171,676,135✔

2400

  STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo));

171,676,135✔

2401

  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

171,590,883✔

2402

  if (pInfo == NULL || pOperator == NULL) {

171,599,966✔

2403

    code = terrno;

157✔

2407

  pOperator->pPhyNode = pTableScanNode;

171,604,852✔

2408

  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;

171,607,926✔

2409

  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;

171,604,089✔

2411

  int32_t numOfCols = 0;

171,630,529✔

2413

      extractColMatchInfo(pScanNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->base.matchInfo);

171,637,111✔

2414

  QUERY_CHECK_CODE(code, lino, _error);

171,590,868✔

2416

  initLimitInfo(pScanNode->node.pLimit, pScanNode->node.pSlimit, &pInfo->base.limitInfo);

171,590,868✔

2417

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, true);

171,516,477✔

2418

  QUERY_CHECK_CODE(code, lino, _error);

171,335,050✔

2420

  if (pScanNode->pScanPseudoCols != NULL) {

171,335,050✔

2421

    SExprSupp* pSup = &pInfo->base.pseudoSup;

49,294,568✔

2422

    pSup->pExprInfo = NULL;

49,351,351✔

2423

    code = createExprInfo(pScanNode->pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);

49,363,245✔

2424

    QUERY_CHECK_CODE(code, lino, _error);

49,309,295✔

2426

    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,

49,309,295✔

2428

    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);

49,365,957✔

2431

  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};

171,376,227✔

2432

  pInfo->base.scanFlag = (pInfo->scanInfo.numOfAsc > 1) ? PRE_SCAN : MAIN_SCAN;

171,198,080✔

2434

  pInfo->base.pdInfo.interval = extractIntervalInfo(pTableScanNode);

171,401,198✔

2435

  pInfo->base.readHandle = *readHandle;

171,063,435✔

2436

  pInfo->base.dataBlockLoadFlag = pTableScanNode->dataRequired;

171,334,656✔

2438

  pInfo->sample.sampleRatio = pTableScanNode->ratio;

171,190,734✔

2439

  pInfo->sample.seed = taosGetTimestampSec();

171,404,277✔

2441

  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;

171,282,614✔

2442

  initResultSizeInfo(&pOperator->resultInfo, 4096);

171,393,550✔

2443

  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);

171,069,164✔

2444

  resetClolumnReserve(pInfo->pResBlock, pInfo->base.dataBlockLoadFlag);

171,622,871✔

2445

  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);

171,123,143✔

2447

  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);

171,114,090✔

2448

  QUERY_CHECK_CODE(code, lino, _error);

171,126,429✔

2450

  pInfo->virtualStableScan = pScanNode->virtualStableScan;

171,126,429✔

2451

  if (pScanNode->node.dynamicOp && pScanNode->virtualStableScan) {

171,152,077✔

2452

    TSWAP(pInfo->pOrgBlock, pInfo->pResBlock);

6,027,191✔

2453

    pInfo->pResBlock = NULL;

6,022,090✔

2454

    memcpy(&pInfo->base.orgCond, &pInfo->base.cond, sizeof(SQueryTableDataCond));

6,029,270✔

2455

    memset(&pInfo->base.cond, 0, sizeof(SQueryTableDataCond));

6,023,632✔

2458

  if (pInfo->virtualStableScan) {

171,144,177✔

2459

    pInfo->readerCache = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);

6,023,465✔

2460

    QUERY_CHECK_NULL(pInfo->readerCache, code, lino, _error, terrno);

6,029,759✔

2463

  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,

171,392,176✔

2464

                            pTaskInfo->pStreamRuntimeInfo);

171,348,268✔

2465

  QUERY_CHECK_CODE(code, lino, _error);

171,118,329✔

2467

  pInfo->currentGroupId = -1;

171,096,113✔

2469

  pInfo->tableEndIndex = -1;

171,344,949✔

2470

  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;

171,326,587✔

2471

  pInfo->hasGroupByTag = pTableScanNode->pGroupTags ? true : false;

171,190,936✔

2473

  setOperatorInfo(pOperator, "TableScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,

171,395,496✔

2475

  pOperator->exprSupp.numOfExprs = numOfCols;

171,031,347✔

2477

  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;

171,225,882✔

2478

  pInfo->ignoreTag = false;

171,321,854✔

2480

  pInfo->lastBatchIdx = -1;

171,139,069✔

2481

  pInfo->currentBatchIdx = 0;

171,025,951✔

2482

  pInfo->base.pTableListInfo = pTableListInfo;

171,321,817✔

2483

  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {

171,158,470✔

2493

  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;

171,158,470✔

2495

  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,

171,046,586✔

2501

  setOperatorResetStateFn(pOperator, resetTableScanOperatorState);

171,106,859✔

2503

  pOperator->cost.openCost = 0;

171,021,438✔

2504

  *pOptrInfo = pOperator;

171,012,341✔

2505

  return TSDB_CODE_SUCCESS;

170,910,146✔

2507

_error:

22,216✔

2508

  if (pInfo != NULL) {

22,216✔

2509

    pInfo->base.pTableListInfo = NULL;  // this attribute will be destroy outside of this function

22,216✔

2510

    destroyTableScanOperatorInfo(pInfo);

22,216✔

2513

  if (pOperator != NULL) {

22,216✔

2514

    pOperator->info = NULL;

22,216✔

2515

    destroyOperator(pOperator);

22,216✔

2517

  pTaskInfo->code = code;

22,216✔

2518

  return code;

22,216✔

2555

static int32_t doBlockDataPrimaryKeyFilter(SSDataBlock* pBlock, STqOffsetVal* offset) {

13,612✔

2556

  int32_t code = TSDB_CODE_SUCCESS;

13,612✔

2557

  int32_t lino = 0;

13,612✔

2558

  if (pBlock->info.window.skey != offset->ts || offset->primaryKey.type == 0) {

13,612✔

2559

    return code;

1,627✔

2561

  bool* p = taosMemoryCalloc(pBlock->info.rows, sizeof(bool));

11,985✔

2562

  QUERY_CHECK_NULL(p, code, lino, _end, terrno);

11,985✔

2563

  bool hasUnqualified = false;

11,985✔

2565

  SColumnInfoData* pColTs = taosArrayGet(pBlock->pDataBlock, 0);

11,985✔

2566

  SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1);

11,985✔

2568

  qDebug("doBlockDataWindowFilter primary key, ts:%" PRId64 " %" PRId64, offset->ts,

11,985✔

2570

  QUERY_CHECK_CONDITION((pColPk->info.type == offset->primaryKey.type), code, lino, _end,

11,985✔

2573

  __compar_fn_t func = getComparFunc(pColPk->info.type, 0);

11,985✔

2574

  QUERY_CHECK_NULL(func, code, lino, _end, terrno);

11,985✔

2575

  for (int32_t i = 0; i < pBlock->info.rows; ++i) {

43,123,557✔

2576

    int64_t* ts = (int64_t*)colDataGetData(pColTs, i);

43,111,572✔

2577

    void*    data = colDataGetData(pColPk, i);

43,111,572✔

2578

    if (IS_VAR_DATA_TYPE(pColPk->info.type)) {

43,113,900✔

2579

      if (IS_STR_DATA_BLOB(pColPk->info.type)) {

2,328✔

2582

      void* tmq = taosMemoryMalloc(offset->primaryKey.nData + VARSTR_HEADER_SIZE);

2,328✔

2583

      QUERY_CHECK_NULL(tmq, code, lino, _end, terrno);

2,328✔

2584

      memcpy(varDataVal(tmq), offset->primaryKey.pData, offset->primaryKey.nData);

2,328✔

2585

      varDataLen(tmq) = offset->primaryKey.nData;

2,328✔

2586

      p[i] = (*ts > offset->ts) || (func(data, tmq) > 0);

2,328✔

2587

      taosMemoryFree(tmq);

2,328✔

2589

      p[i] = (*ts > offset->ts) || (func(data, VALUE_GET_DATUM(&offset->primaryKey, pColPk->info.type)) > 0);

43,109,244✔

2592

    if (!p[i]) {

43,111,572✔

2593

      hasUnqualified = true;

15,336,006✔

2597

  if (hasUnqualified) {

11,985✔

2598

    code = trimDataBlock(pBlock, pBlock->info.rows, p);

4,035✔

2599

    QUERY_CHECK_CODE(code, lino, _end);

4,035✔

2602

_end:

11,985✔

2603

  taosMemoryFree(p);

11,985✔

2604

  if (code != TSDB_CODE_SUCCESS) {

11,985✔

2607

  return code;

11,985✔

2610

int32_t colIdComparFn(const void* param1, const void* param2) {

1,318,736,670✔

2611

  int32_t p1 = *(int32_t*)param1;

1,318,736,670✔

2612

  int32_t p2 = *(int32_t*)param2;

1,318,748,395✔

2614

  if (p1 == p2) {

1,318,746,360✔

2617

    return (p1 < p2) ? -1 : 1;

1,318,746,360✔

2621

static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock) {

92,320,707✔

2622

  int32_t         code = TSDB_CODE_SUCCESS;

92,320,707✔

2623

  int32_t         lino = 0;

92,320,707✔

2624

  SDataBlockInfo* pBlockInfo = &pInfo->pRes->info;

92,320,707✔

2625

  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;

92,322,023✔

2626

  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;

92,322,023✔

2627

  const char*     id = GET_TASKID(pTaskInfo);

92,321,689✔

2628

  SArray* pColList = NULL;

92,322,695✔

2630

  code = blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows);

92,322,695✔

2631

  QUERY_CHECK_CODE(code, lino, _end);

92,321,082✔

2633

  pBlockInfo->rows = pBlock->info.rows;

92,321,082✔

2634

  pBlockInfo->id.uid = pBlock->info.id.uid;

92,321,418✔

2635

  pBlockInfo->type = STREAM_NORMAL;

92,319,091✔

2636

  pBlockInfo->version = pBlock->info.version;

92,320,767✔

2638

  STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;

92,320,664✔

2639

  pBlockInfo->id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);

92,320,328✔

2641

  pColList = taosArrayInit(4, sizeof(int32_t));

92,320,013✔

2642

  QUERY_CHECK_NULL(pColList, code, lino, _end, terrno);

92,322,019✔

2645

  for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {

497,773,756✔

2646

    SColMatchItem* pColMatchInfo = taosArrayGet(pInfo->matchInfo.pList, i);

405,467,049✔

2647

    if (!pColMatchInfo->needOutput) {

405,457,384✔

2648

      continue;

630✔

2651

    bool colExists = false;

405,464,383✔

2652

    for (int32_t j = 0; j < blockDataGetNumOfCols(pBlock); ++j) {

1,281,880,039✔

2653

      SColumnInfoData* pResCol = NULL;

1,281,182,815✔

2654

      code = bdGetColumnInfoData(pBlock, j, &pResCol);

1,281,081,974✔

2655

      QUERY_CHECK_CODE(code, lino, _end);

1,281,243,588✔

2657

      if (pResCol->info.colId == pColMatchInfo->colId) {

1,281,243,588✔

2658

        SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->dstSlotId);

405,507,844✔

2659

        code = colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info);

405,506,746✔

2660

        QUERY_CHECK_CODE(code, lino, _end);

405,382,471✔

2662

        colExists = true;

405,382,471✔

2663

        void* tmp = taosArrayPush(pColList, &pColMatchInfo->dstSlotId);

405,382,471✔

2664

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

405,461,820✔

2665

        break;

405,461,820✔

2670

    if (!colExists) {

405,451,107✔

2679

  if (pInfo->numOfPseudoExpr > 0) {

92,319,066✔

2680

    code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,

113,104,846✔

2681

                                  pBlockInfo->rows, pTaskInfo, &pTableScanInfo->base.metaCache);

56,552,510✔

2683

    if (code) {

56,551,552✔

2688

    terrno = 0;

56,551,552✔

2690

    for (int32_t i = 0; i < pInfo->numOfPseudoExpr; ++i) {

240,195,263✔

2691

      void* tmp = taosArrayPush(pColList, &pInfo->pPseudoExpr[i].base.resSchema.slotId);

183,641,657✔

2692

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

183,646,449✔

2696

  taosArraySort(pColList, colIdComparFn);

92,306,012✔

2698

  int32_t i = 0, j = 0;

92,319,427✔

2699

  while (i < taosArrayGetSize(pColList)) {

681,324,856✔

2700

    int32_t slot1 = *(int32_t*)taosArrayGet(pColList, i);

588,987,015✔

2701

    if (slot1 > j) {

589,005,429✔

2706

      i += 1;

589,005,429✔

2707

      j += 1;

589,005,429✔

2711

  while (j < taosArrayGetSize(pInfo->pRes->pDataBlock)) {

92,316,690✔

2712

    SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, j);

630✔

2713

    colDataSetNNULL(pDst, 0, pBlockInfo->rows);

630✔

2714

    j += 1;

630✔

2717

  code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL, NULL);

92,315,387✔

2718

  QUERY_CHECK_CODE(code, lino, _end);

92,315,255✔

2720

  code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);

92,315,255✔

2721

  QUERY_CHECK_CODE(code, lino, _end);

92,315,442✔

2723

_end:

92,315,442✔

2724

  taosArrayDestroy(pColList);

91,727,321✔

2725

  if (code != TSDB_CODE_SUCCESS) {

92,312,225✔

2728

  return code;

92,308,944✔

2731

static int32_t processPrimaryKey(SSDataBlock* pBlock, bool hasPrimaryKey, STqOffsetVal* offset) {

6,591,820✔

2732

  int32_t code = TSDB_CODE_SUCCESS;

6,591,820✔

2733

  int32_t lino = 0;

6,591,820✔

2734

  SValue  val = {0};

6,591,820✔

2735

  if (hasPrimaryKey) {

6,592,383✔

2736

    code = doBlockDataPrimaryKeyFilter(pBlock, offset);

13,612✔

2737

    if (code != TSDB_CODE_SUCCESS) {

13,612✔

2741

    SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1);

13,612✔

2743

    if (pBlock->info.rows < 1) {

13,612✔

2744

      return code;

3,744✔

2746

    void* tmp = colDataGetData(pColPk, pBlock->info.rows - 1);

9,868✔

2747

    val.type = pColPk->info.type;

9,868✔

2748

    if (IS_VAR_DATA_TYPE(pColPk->info.type)) {

9,868✔

2749

      if (IS_STR_DATA_BLOB(pColPk->info.type)) {

625✔

2752

      val.pData = taosMemoryMalloc(varDataLen(tmp));

625✔

2753

      QUERY_CHECK_NULL(val.pData, code, lino, _end, terrno);

625✔

2754

      val.nData = varDataLen(tmp);

625✔

2755

      memcpy(val.pData, varDataVal(tmp), varDataLen(tmp));

625✔

2757

      valueSetDatum(&val, pColPk->info.type, tmp, pColPk->info.bytes);

9,243✔

2760

  tqOffsetResetToData(offset, pBlock->info.id.uid, pBlock->info.window.ekey, val);

6,588,639✔

2762

_end:

6,587,172✔

2763

  if (code != TSDB_CODE_SUCCESS) {

6,587,479✔

2766

  return code;

6,587,479✔

2769

static int32_t doQueueScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

118,301,577✔

2770

  int32_t        code = TSDB_CODE_SUCCESS;

118,301,577✔

2771

  int32_t        lino = 0;

118,301,577✔

2772

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

118,301,577✔

2773

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

118,305,246✔

2775

  SStreamScanInfo* pInfo = pOperator->info;

118,307,229✔

2776

  const char*      id = GET_TASKID(pTaskInfo);

118,302,965✔

2778

  qDebug("start to exec queue scan, %s", id);

118,304,303✔

2780

  if (isTaskKilled(pTaskInfo)) {

118,309,209✔

2785

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_DATA) {

118,308,903✔

2786

    while (1) {

3,744✔

2787

      SSDataBlock* pResult = NULL;

5,922,508✔

2788

      code = doTableScanNext(pInfo->pTableScanOp, &pResult);

5,922,508✔

2789

      QUERY_CHECK_CODE(code, lino, _end);

5,920,973✔

2791

      if (pResult && pResult->info.rows > 0) {

5,920,973✔

2792

        bool hasPrimaryKey = pAPI->tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader);

5,878,829✔

2793

        code = processPrimaryKey(pResult, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);

5,880,057✔

2794

        QUERY_CHECK_CODE(code, lino, _end);

5,878,522✔

2795

        qDebug("tmqsnap doQueueScan get data utid:%" PRId64, pResult->info.id.uid);

5,878,522✔

2796

        if (pResult->info.rows > 0) {

5,880,671✔

2797

          (*ppRes) = pResult;

5,876,313✔

2798

          return code;

5,876,313✔

2805

    STableScanInfo* pTSInfo = pInfo->pTableScanOp->info;

42,451✔

2806

    pAPI->tsdReader.tsdReaderClose(pTSInfo->base.dataReader);

42,451✔

2808

    pTSInfo->base.dataReader = NULL;

42,451✔

2809

    int64_t validVer = pTaskInfo->streamInfo.snapshotVer + 1;

42,451✔

2810

    qDebug("queue scan tsdb over, switch to wal ver %" PRId64, validVer);

42,451✔

2811

    if (pAPI->tqReaderFn.tqReaderSeek(pInfo->tqReader, validVer, pTaskInfo->id.str) < 0) {

42,451✔

2812

      (*ppRes) = NULL;

13,385✔

2813

      return code;

13,385✔

2816

    tqOffsetResetToLog(&pTaskInfo->streamInfo.currentOffset, validVer);

29,066✔

2819

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__LOG) {

112,419,541✔

2820

    while (1) {

737,670✔

2822

          pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id, pTaskInfo->streamInfo.sourceExcluded);

113,156,875✔

2824

      SSDataBlock*       pRes = pAPI->tqReaderFn.tqGetResultBlock(pInfo->tqReader);

113,126,678✔

2825

      struct SWalReader* pWalReader = pAPI->tqReaderFn.tqReaderGetWalReader(pInfo->tqReader);

113,138,472✔

2828

      tqOffsetResetToLog(&pTaskInfo->streamInfo.currentOffset, pWalReader->curVersion);

113,148,907✔

2831

      pTaskInfo->streamInfo.currentOffset.ts = pAPI->tqReaderFn.tqGetResultBlockTime(pInfo->tqReader);

113,144,549✔

2833

      if (hasResult) {

113,147,237✔

2834

        qDebug("doQueueScan get data from log %" PRId64 " rows, version:%" PRId64, pRes->info.rows,

92,311,713✔

2836

        blockDataCleanup(pInfo->pRes);

92,321,263✔

2837

        code = setBlockIntoRes(pInfo, pRes);

92,317,991✔

2838

        QUERY_CHECK_CODE(code, lino, _end);

92,308,646✔

2839

        qDebug("doQueueScan after filter get data from log %" PRId64 " rows, version:%" PRId64, pInfo->pRes->info.rows,

92,308,646✔

2841

        if (pInfo->pRes->info.rows > 0) {

92,309,994✔

2842

          (*ppRes) = pInfo->pRes;

91,583,345✔

2843

          return code;

91,581,718✔

2846

        qDebug("doQueueScan get none from log, return, version:%" PRId64, pTaskInfo->streamInfo.currentOffset.version);

20,835,524✔

2847

        (*ppRes) = NULL;

20,835,842✔

2848

        return code;

20,835,524✔

2873

int32_t extractTableIdList(const STableListInfo* pTableListInfo, SArray** ppArrayRes) {

316,240✔

2874

  int32_t code = TSDB_CODE_SUCCESS;

316,240✔

2875

  int32_t lino = 0;

316,240✔

2876

  SArray* tableIdList = taosArrayInit(4, sizeof(uint64_t));

316,240✔

2877

  QUERY_CHECK_NULL(tableIdList, code, lino, _end, terrno);

319,327✔

2880

  int32_t size = 0;

319,327✔

2881

  code = tableListGetSize(pTableListInfo, &size);

319,327✔

2882

  QUERY_CHECK_CODE(code, lino, _end);

319,949✔

2883

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

9,265,300✔

2884

    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);

8,944,748✔

2885

    QUERY_CHECK_NULL(pkeyInfo, code, lino, _end, terrno);

8,936,457✔

2886

    void* tmp = taosArrayPush(tableIdList, &pkeyInfo->uid);

8,936,457✔

2887

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

8,945,351✔

2890

  (*ppArrayRes) = tableIdList;

320,552✔

2892

_end:

319,949✔

2893

  if (code != TSDB_CODE_SUCCESS) {

319,949✔

2896

  return code;

319,949✔

2899

static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

1,464,670✔

2900

  int32_t        code = TSDB_CODE_SUCCESS;

1,464,670✔

2901

  int32_t        lino = 0;

1,464,670✔

2902

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

1,464,670✔

2903

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

1,464,670✔

2905

  SStreamRawScanInfo* pInfo = pOperator->info;

1,464,670✔

2906

  pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = NULL;  // use batchMetaReq != NULL to judge if data is meta

1,464,670✔

2907

  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;

1,464,670✔

2909

  qDebug("tmqsnap doRawScan called");

1,464,670✔

2910

  if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_DATA) {

1,464,670✔

2911

    bool hasNext = false;

1,459,976✔

2912

    if (pInfo->dataReader && pInfo->sContext->withMeta != ONLY_META) {

1,459,976✔

2913

      code = pAPI->tsdReader.tsdNextDataBlock(pInfo->dataReader, &hasNext);

1,459,150✔

2914

      if (code != TSDB_CODE_SUCCESS) {

1,456,240✔

2920

    if (pInfo->dataReader && hasNext) {

1,457,066✔

2921

      if (isTaskKilled(pTaskInfo)) {

714,748✔

2926

      SSDataBlock* pBlock = NULL;

715,038✔

2927

      code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pInfo->dataReader, &pBlock);

715,038✔

2928

      QUERY_CHECK_CODE(code, lino, _end);

713,878✔

2930

      if (pBlock && pBlock->info.rows > 0) {

713,878✔

2931

        bool hasPrimaryKey = pAPI->snapshotFn.taosXGetTablePrimaryKey(pInfo->sContext);

713,878✔

2932

        code = processPrimaryKey(pBlock, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);

713,588✔

2933

        QUERY_CHECK_CODE(code, lino, _end);

713,298✔

2934

        qDebug("tmqsnap doRawScan get data uid:%" PRId64, pBlock->info.id.uid);

713,298✔

2935

        (*ppRes) = pBlock;

714,748✔

2936

        return code;

715,038✔

2940

    SMetaTableInfo mtInfo = {0};

743,193✔

2941

    code = pAPI->snapshotFn.getMetaTableInfoFromSnapshot(pInfo->sContext, &mtInfo);

744,348✔

2942

    QUERY_CHECK_CODE(code, lino, _end);

743,778✔

2943

    if (code != 0) {

743,778✔

2947

    STqOffsetVal offset = {0};

743,778✔

2948

    if (mtInfo.uid == 0 || pInfo->sContext->withMeta == ONLY_META) {  // read snapshot done, change to get data from wal

742,903✔

2949

      qDebug("tmqsnap read snapshot done, change to get data from wal");

11,198✔

2950

      tqOffsetResetToLog(&offset, pInfo->sContext->snapVersion + 1);

11,198✔

2952

      SValue val = {0};

733,150✔

2953

      tqOffsetResetToData(&offset, mtInfo.uid, INT64_MIN, val);

733,150✔

2954

      qDebug("tmqsnap change get data uid:%" PRId64, mtInfo.uid);

733,445✔

2957

    code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType);

744,938✔

2958

    QUERY_CHECK_CODE(code, lino, _end);

744,938✔

2959

    (*ppRes) = NULL;

744,938✔

2960

    return code;

744,938✔

2961

  } else if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_META) {

4,694✔

2962

    SSnapContext* sContext = pInfo->sContext;

4,694✔

2963

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

39,008✔

2964

      void*   data = NULL;

39,008✔

2965

      int32_t dataLen = 0;

39,008✔

2966

      int16_t type = 0;

39,008✔

2967

      int64_t uid = 0;

39,008✔

2968

      if (pAPI->snapshotFn.getTableInfoFromSnapshot(sContext, &data, &dataLen, &type, &uid) < 0) {

39,008✔

2974

      if (!sContext->queryMeta) {  // change to get data next poll request

39,008✔

2975

        STqOffsetVal offset = {0};

4,694✔

2976

        SValue       val = {0};

4,694✔

2978

        code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType);

4,694✔

2979

        QUERY_CHECK_CODE(code, lino, _end);

4,694✔

2980

        break;

4,694✔

2982

        tqOffsetResetToMeta(&pTaskInfo->streamInfo.currentOffset, uid);

34,314✔

2983

        SMqMetaRsp tmpMetaRsp = {0};

34,314✔

2984

        tmpMetaRsp.resMsgType = type;

34,314✔

2985

        tmpMetaRsp.metaRspLen = dataLen;

34,314✔

2986

        tmpMetaRsp.metaRsp = data;

34,314✔

2987

        if (!pTaskInfo->streamInfo.btMetaRsp.batchMetaReq) {

34,314✔

2988

          pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = taosArrayInit(4, POINTER_BYTES);

4,178✔

2989

          QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, code, lino, _end, terrno);

4,178✔

2991

          pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = taosArrayInit(4, sizeof(int32_t));

4,178✔

2992

          QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, code, lino, _end, terrno);

4,178✔

2994

        int32_t  tempRes = TSDB_CODE_SUCCESS;

34,314✔

2995

        uint32_t len = 0;

34,314✔

2996

        tEncodeSize(tEncodeMqMetaRsp, &tmpMetaRsp, len, tempRes);

34,314✔

2997

        if (TSDB_CODE_SUCCESS != tempRes) {

34,314✔

3003

        int32_t tLen = sizeof(SMqRspHead) + len;

34,314✔

3004

        void*   tBuf = taosMemoryCalloc(1, tLen);

34,314✔

3005

        QUERY_CHECK_NULL(tBuf, code, lino, _end, terrno);

34,056✔

3007

        void*    metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead));

34,056✔

3008

        SEncoder encoder = {0};

34,056✔

3009

        tEncoderInit(&encoder, metaBuff, len);

34,056✔

3010

        int32_t tempLen = tEncodeMqMetaRsp(&encoder, &tmpMetaRsp);

34,056✔

3011

        if (tempLen < 0) {

34,056✔

3018

        taosMemoryFreeClear(data);

34,056✔

3019

        void* tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, &tBuf);

34,314✔

3020

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

34,314✔

3022

        tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, &tLen);

34,314✔

3023

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

34,314✔

3027

    (*ppRes) = NULL;

4,694✔

3028

    return code;

4,694✔

3042

static void destroyTmqRawScanOperatorInfo(void* param) {

118,010✔

3043

  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;

118,010✔

3044

  pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader);

118,010✔

3045

  pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext);

118,010✔

3046

  tableListDestroy(pRawScan->pTableListInfo);

117,676✔

3047

  taosMemoryFree(pRawScan);

118,010✔

3048

117,752✔

3053

int32_t createTmqRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {

117,391✔

3059

  QRY_PARAM_CHECK(pOptrInfo);

117,391✔

3060

  int32_t code = TSDB_CODE_SUCCESS;

117,686✔

3061

  int32_t lino = 0;

117,686✔

3063

  SStreamRawScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamRawScanInfo));

117,686✔

3064

  SOperatorInfo*      pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

118,010✔

3065

  if (pInfo == NULL || pOperator == NULL) {

117,686✔

3071

  pInfo->pTableListInfo = tableListCreate();

117,686✔

3072

  QUERY_CHECK_NULL(pInfo->pTableListInfo, code, lino, _end, terrno);

118,010✔

3073

  pInfo->vnode = pHandle->vnode;

118,010✔

3074

  pInfo->pAPI = &pTaskInfo->storageAPI;

118,010✔

3076

  pInfo->sContext = pHandle->sContext;

118,010✔

3077

  pHandle->sContext = NULL;  // transfer the ownership

118,010✔

3078

  setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,

118,010✔

3081

  pOperator->fpSet = createOperatorFpSet(NULL, doRawScanNext, NULL, destroyTmqRawScanOperatorInfo, optrDefaultBufFn,

118,010✔

3083

  *pOptrInfo = pOperator;

118,010✔

3084

  return code;

118,010✔

3096

void destroyTmqScanOperatorInfo(void* param) {

319,615✔

3097

  if (param == NULL) {

319,615✔

3101

  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;

319,615✔

3102

  if (pStreamScan->pTableScanOp && pStreamScan->pTableScanOp->info) {

319,615✔

3103

    destroyOperator(pStreamScan->pTableScanOp);

319,615✔

3106

  if (pStreamScan->tqReader != NULL && pStreamScan->readerFn.tqReaderClose != NULL) {

319,655✔

3107

    pStreamScan->readerFn.tqReaderClose(pStreamScan->tqReader);

319,655✔

3109

  if (pStreamScan->pVtableMergeHandles) {

319,655✔

3113

  if (pStreamScan->pVtableMergeBuf) {

319,949✔

3117

  if (pStreamScan->pVtableReadyHandles) {

319,949✔

3121

  if (pStreamScan->pTableListInfo) {

319,949✔

3125

  if (pStreamScan->matchInfo.pList) {

319,949✔

3126

    taosArrayDestroy(pStreamScan->matchInfo.pList);

319,643✔

3128

  if (pStreamScan->pPseudoExpr) {

320,255✔

3129

    destroyExprInfo(pStreamScan->pPseudoExpr, pStreamScan->numOfPseudoExpr);

184,875✔

3130

    taosMemoryFree(pStreamScan->pPseudoExpr);

184,875✔

3133

  cleanupExprSupp(&pStreamScan->tbnameCalSup);

319,949✔

3134

  cleanupExprSupp(&pStreamScan->tagCalSup);

319,949✔

3136

  blockDataDestroy(pStreamScan->pRes);

319,949✔

3137

  blockDataDestroy(pStreamScan->pUpdateRes);

319,949✔

3138

  blockDataDestroy(pStreamScan->pDeleteDataRes);

319,649✔

3139

  blockDataDestroy(pStreamScan->pUpdateDataRes);

319,381✔

3140

  blockDataDestroy(pStreamScan->pCreateTbRes);

319,649✔

3141

  taosArrayDestroy(pStreamScan->pBlockLists);

319,381✔

3142

  blockDataDestroy(pStreamScan->pCheckpointRes);

319,347✔

3144

  taosMemoryFree(pStreamScan);

319,949✔

3164

 int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,

318,928✔

3167

  QRY_PARAM_CHECK(pOptrInfo);

318,928✔

3169

  int32_t          code = TSDB_CODE_SUCCESS;

319,949✔

3170

  int32_t          lino = 0;

319,949✔

3171

  SArray*          pColIds = NULL;

319,949✔

3172

  SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));

319,949✔

3173

  SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

319,949✔

3174

  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;

319,949✔

3175

  const char*      idstr = pTaskInfo->id.str;

319,949✔

3177

  if (pInfo == NULL || pOperator == NULL) {

319,949✔

3182

  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;

319,949✔

3183

  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;

319,949✔

3185

  pInfo->pTagCond = pTagCond;

319,949✔

3186

  pInfo->pGroupTags = pTableScanNode->pGroupTags;

319,949✔

3188

  int32_t numOfCols = 0;

319,949✔

3189

  code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);

319,949✔

3190

  if (code != TSDB_CODE_SUCCESS) {

319,949✔

3194

  SDataType pkType = {0};

319,949✔

3195

  pInfo->primaryKeyIndex = -1;

319,949✔

3196

  pInfo->basic.primaryPkIndex = -1;

319,949✔

3197

  int32_t numOfOutput = taosArrayGetSize(pInfo->matchInfo.pList);

319,949✔

3198

  pColIds = taosArrayInit(numOfOutput, sizeof(int16_t));

319,949✔

3199

  QUERY_CHECK_NULL(pColIds, code, lino, _error, terrno);

319,655✔

3201

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

2,011,803✔

3202

    SColMatchItem* id = taosArrayGet(pInfo->matchInfo.pList, i);

1,691,876✔

3203

    QUERY_CHECK_NULL(id, code, lino, _error, terrno);

1,691,854✔

3205

    int16_t colId = id->colId;

1,691,854✔

3206

    void*   tmp = taosArrayPush(pColIds, &colId);

1,692,421✔

3207

    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);

1,692,421✔

3209

    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {

1,692,421✔

3210

      pInfo->primaryTsIndex = id->dstSlotId;

319,949✔

3212

    if (id->isPk) {

1,692,085✔

3213

      pInfo->primaryKeyIndex = id->dstSlotId;

1,492✔

3214

      pInfo->basic.primaryPkIndex = id->dstSlotId;

1,492✔

3215

      pkType = id->dataType;

1,492✔

3219

  pInfo->pPartTbnameSup = NULL;

319,927✔

3220

  if (pTableScanNode->pSubtable != NULL) {

319,949✔

3236

  if (pTableScanNode->pTags != NULL) {

319,949✔

3248

  pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));

319,319✔

3249

  TSDB_CHECK_NULL(pInfo->pBlockLists, code, lino, _error, terrno);

319,677✔

3251

  if (pHandle->vnode) {

319,383✔

3252

    SOperatorInfo* pTableScanOp = NULL;

319,949✔

3253

    code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp);

319,949✔

3254

    if (pTableScanOp == NULL || code != 0) {

319,512✔

3255

      qError("createTableScanOperatorInfo error, code:%d", pTaskInfo->code);

2,037✔

3259

    STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info;

317,475✔

3260

    if (pHandle->version > 0) {

318,999✔

3261

      pTSInfo->base.cond.endVersion = pHandle->version;

318,556✔

3264

    STableKeyInfo* pList = NULL;

317,510✔

3265

    int32_t        num = 0;

317,401✔

3266

    code = tableListGetGroupList(pTableListInfo, 0, &pList, &num);

318,729✔

3267

    QUERY_CHECK_CODE(code, lino, _error);

318,812✔

3269

    if (pHandle->initTableReader) {

318,812✔

3270

      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;

318,981✔

3271

      pTSInfo->base.dataReader = NULL;

318,996✔

3274

    if (pHandle->initTqReader) {

318,949✔

3275

      pInfo->tqReader = pAPI->tqReaderFn.tqReaderOpen(pHandle->vnode);

318,579✔

3276

      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, terrno);

319,949✔

3278

      pInfo->tqReader = pHandle->tqReader;

708✔

3282

    pInfo->pUpdateInfo = NULL;

319,949✔

3283

    pInfo->pTableScanOp = pTableScanOp;

319,949✔

3284

    if (pInfo->pTableScanOp->pTaskInfo->streamInfo.pState) {

319,949✔

3289

    pInfo->readHandle = *pHandle;

319,949✔

3290

    pTaskInfo->streamInfo.snapshotVer = pHandle->version;

319,949✔

3291

    pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup);

319,949✔

3292

    QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, terrno);

319,681✔

3293

    pInfo->hasPart = false;

318,972✔

3295

    code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8);

319,509✔

3296

    QUERY_CHECK_CODE(code, lino, _error);

319,615✔

3299

    code = pAPI->tqReaderFn.tqReaderSetColIdList(pInfo->tqReader, pColIds, idstr);

319,615✔

3300

    QUERY_CHECK_CODE(code, lino, _error);

319,439✔

3302

    SArray* tableIdList = NULL;

319,439✔

3303

    code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList);

319,439✔

3304

    QUERY_CHECK_CODE(code, lino, _error);

319,780✔

3305

    code = pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr);

319,780✔

3306

    QUERY_CHECK_CODE(code, lino, _error);

319,949✔

3307

    taosArrayDestroy(tableIdList);

319,949✔

3308

    memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));

319,949✔

3315

  pColIds = NULL;

319,949✔

3318

  if (pTableScanNode->scan.pScanPseudoCols != NULL) {

319,949✔

3319

    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);

184,875✔

3320

    QUERY_CHECK_CODE(code, lino, _error);

184,875✔

3323

  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0, NULL);

319,949✔

3324

  QUERY_CHECK_CODE(code, lino, _error);

319,949✔

3326

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

319,949✔

3327

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

319,949✔

3328

  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateRes);

319,949✔

3329

  QUERY_CHECK_CODE(code, lino, _error);

319,780✔

3331

  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;

319,780✔

3332

  pInfo->windowSup = (SWindowSupporter){.pStreamAggSup = NULL, .gap = -1, .parentType = QUERY_NODE_PHYSICAL_PLAN};

319,780✔

3333

  pInfo->groupId = 0;

319,949✔

3334

  pInfo->igCheckGroupId = false;

319,494✔

3335

  pInfo->pStreamScanOp = pOperator;

319,188✔

3336

  pInfo->deleteDataIndex = 0;

319,780✔

3337

  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pInfo->pDeleteDataRes);

319,643✔

3338

  QUERY_CHECK_CODE(code, lino, _error);

319,949✔

3340

  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};

319,949✔

3341

  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateDataRes);

319,949✔

3342

  QUERY_CHECK_CODE(code, lino, _error);

319,949✔

3344

  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;

319,949✔

3345

  pInfo->partitionSup.needCalc = false;

319,949✔

3346

  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;

319,949✔

3347

  pInfo->igExpired = pTableScanNode->igExpired;

319,949✔

3348

  pInfo->twAggSup.maxTs = INT64_MIN;

319,949✔

3349

  pInfo->pState = pTaskInfo->streamInfo.pState;

319,949✔

3350

  pInfo->stateStore = pTaskInfo->storageAPI.stateStore;

319,949✔

3351

  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;

319,949✔

3352

  pInfo->pFillSup = NULL;

319,949✔

3353

  pInfo->useGetResultRange = false;

319,346✔

3354

  pInfo->pRangeScanRes = NULL;

319,346✔

3356

  code = createSpecialDataBlock(STREAM_CHECKPOINT, &pInfo->pCheckpointRes);

319,346✔

3357

  QUERY_CHECK_CODE(code, lino, _error);

319,678✔

3359

  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,

319,678✔

3361

  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);

319,678✔

3363

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doQueueScanNext, NULL, destroyTmqScanOperatorInfo, optrDefaultBufFn,

319,678✔

3366

  *pOptrInfo = pOperator;

319,949✔

3367

  return code;

319,949✔

3390

static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {

10,587,368✔

3391

  int32_t        code = TSDB_CODE_SUCCESS;

10,587,368✔

3392

  int32_t        lino = 0;

10,587,368✔

3393

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

10,587,368✔

3394

  STagScanInfo*  pInfo = pOperator->info;

10,589,892✔

3395

  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];

10,589,406✔

3396

  int32_t        count = pRes->info.rows;

10,589,393✔

3398

  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);

10,588,402✔

3399

  if (!item) {

10,585,921✔

3406

  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);

10,585,921✔

3407

  tDecoderClear(&(*mr).coder);

10,590,848✔

3408

  if (code != TSDB_CODE_SUCCESS) {

10,590,877✔

3414

  char str[512];

10,361,957✔

3415

  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

47,692,736✔

3416

    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

37,102,355✔

3419

    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {

37,102,313✔

3420

      STR_TO_VARSTR(str, (*mr).me.name);

4,396,049✔

3421

      code = colDataSetVal(pDst, (count), str, false);

4,395,061✔

3422

      QUERY_CHECK_CODE(code, lino, _end);

4,395,093✔

3423

    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {

32,709,737✔

3424

      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);

6,292,297✔

3425

      QUERY_CHECK_CODE(code, lino, _end);

6,292,297✔

3426

    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {

26,415,952✔

3427

      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);

14,772✔

3428

      QUERY_CHECK_CODE(code, lino, _end);

14,772✔

3430

      STagVal val = {0};

26,400,222✔

3431

      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;

26,400,711✔

3432

      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);

26,401,689✔

3434

      char* data = NULL;

26,401,142✔

3435

      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {

26,401,142✔

3436

        data = tTagValToData((const STagVal*)p, false);

26,399,337✔

3438

        data = (char*)p;

1,344✔

3441

      code = colDataSetVal(pDst, (count), data,

26,401,688✔

3442

                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));

26,401,199✔

3443

      QUERY_CHECK_CODE(code, lino, _end);

26,400,241✔

3445

      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&

26,400,241✔

3447

        taosMemoryFree(data);

9,502,812✔

3452

_end:

10,591,843✔

3453

  if (code != TSDB_CODE_SUCCESS) {

10,590,359✔

3457

    pRes->info.rows++;

10,590,359✔

3460

  return code;

10,590,883✔

3463

static void tagScanFreeUidTag(void* p) {

6,754,495✔

3464

  STUidTagInfo* pInfo = p;

6,754,495✔

3465

  if (pInfo->pTagVal != NULL) {

6,754,495✔

3466

    taosMemoryFree(pInfo->pTagVal);

6,754,569✔

3468

6,751,615✔

3470

static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {

1,372,471✔

3471

  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));

1,372,471✔

3472

  if (pColumnData == NULL) {

1,372,590✔

3476

  pColumnData->info.type = pType->type;

1,372,590✔

3477

  pColumnData->info.bytes = pType->bytes;

1,370,758✔

3478

  pColumnData->info.scale = pType->scale;

1,372,620✔

3479

  pColumnData->info.precision = pType->precision;

1,370,902✔

3481

  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);

1,372,722✔

3482

  if (code != TSDB_CODE_SUCCESS) {

1,369,267✔

3488

  pParam->columnData = pColumnData;

1,369,267✔

3489

  pParam->colAlloced = true;

1,372,738✔

3490

  return TSDB_CODE_SUCCESS;

1,372,107✔

3493

static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {

8,426,906✔

3494

  int32_t                code = TSDB_CODE_SUCCESS;

8,426,906✔

3495

  int32_t                lino = 0;

8,426,906✔

3496

  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;

8,426,906✔

3497

  SColumnNode*           pSColumnNode = NULL;

8,426,906✔

3498

  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {

8,428,715✔

3499

    pSColumnNode = *(SColumnNode**)pNode;

2,385,442✔

3500

  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {

6,055,539✔

3501

    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);

484✔

3502

    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {

484✔

3515

      return DEAL_RES_CONTINUE;

484✔

3518

    return DEAL_RES_CONTINUE;

6,047,417✔

3521

  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));

2,385,443✔

3522

  if (!data) {

2,382,890✔

3523

    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));

1,375,933✔

3524

    if (code == TSDB_CODE_DUP_KEY) {

1,378,340✔

3527

    QUERY_CHECK_CODE(code, lino, _end);

1,378,340✔

3528

    pSColumnNode->slotId = pCtx->index++;

1,378,340✔

3529

    SColumnInfo cInfo = {.colId = pSColumnNode->colId,

1,373,074✔

3530

                         .type = pSColumnNode->node.resType.type,

1,376,523✔

3531

                         .bytes = pSColumnNode->node.resType.bytes};

1,374,905✔

3532

    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);

1,377,360✔

3533

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

1,376,721✔

3535

    SColumnNode* col = *(SColumnNode**)data;

1,006,957✔

3536

    pSColumnNode->slotId = col->slotId;

1,006,957✔

3539

_end:

2,381,230✔

3540

  if (code != TSDB_CODE_SUCCESS) {

2,382,700✔

3541

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

980✔

3544

  return DEAL_RES_CONTINUE;

2,381,720✔

3547

static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,

1,375,704✔

3549

  int32_t code = TSDB_CODE_SUCCESS;

1,375,704✔

3550

  int32_t lino = 0;

1,375,704✔

3551

  int32_t numOfTables = taosArrayGetSize(aUidTags);

1,375,704✔

3552

  SArray* pBlockList = NULL;

1,374,890✔

3554

  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);

1,374,890✔

3555

  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);

1,371,419✔

3557

  pBlockList = taosArrayInit(1, POINTER_BYTES);

1,371,419✔

3558

  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);

1,372,745✔

3560

  void* tmp = taosArrayPush(pBlockList, &pResBlock);

1,374,521✔

3561

  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

1,374,521✔

3563

  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};

1,374,521✔

3565

  SScalarParam output = {0};

1,373,279✔

3566

  code = tagScanCreateResultData(&type, numOfTables, &output);

1,372,102✔

3567

  QUERY_CHECK_CODE(code, lino, _end);

1,370,297✔

3569

  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;

1,370,297✔

3570

  gTaskScalarExtra.pStreamRange = NULL;

1,370,297✔

3571

  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);

1,372,108✔

3572

  QUERY_CHECK_CODE(code, lino, _end);

1,370,781✔

3574

  bool* result = (bool*)output.columnData->pData;

1,370,781✔

3575

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

3,429,362✔

3576

    if (result[i]) {

2,058,242✔

3577

      void* tmp = taosArrayPush(aFilterIdxs, &i);

1,911,696✔

3578

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

1,911,696✔

3582

  colDataDestroy(output.columnData);

1,373,427✔

3583

  taosMemoryFreeClear(output.columnData);

1,367,153✔

3585

_end:

1,367,569✔

3586

  blockDataDestroy(pResBlock);

1,366,397✔

3587

  taosArrayDestroy(pBlockList);

1,365,339✔

3588

  if (code != TSDB_CODE_SUCCESS) {

1,365,854✔

3591

  return code;

1,365,854✔

3594

static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,

25,106,672✔

3597

  int32_t code = TSDB_CODE_SUCCESS;

25,106,672✔

3598

  int32_t lino = 0;

25,106,672✔

3599

  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {

25,106,672✔

3600

    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname

11,911,136✔

3606

    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {

11,901,818✔

3607

      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);

5,950,855✔

3608

      QUERY_CHECK_CODE(code, lino, _end);

5,955,654✔

3609

    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {

5,956,462✔

3610

      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);

5,952,495✔

3611

      QUERY_CHECK_CODE(code, lino, _end);

5,956,121✔

3614

    STagVal tagVal = {0};

13,192,139✔

3615

    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;

13,193,751✔

3616

    if (pUidTagInfo->pTagVal == NULL) {

13,196,880✔

3619

      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);

13,193,082✔

3621

      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {

13,195,041✔

3622

        colDataSetNULL(pColInfo, rowIndex);

6,533✔

3623

      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {

13,188,529✔

3626

      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {

16,456,425✔

3627

        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {

3,277,780✔

3630

        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);

3,272,706✔

3631

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

3,271,030✔

3633

        varDataSetLen(tmp, tagVal.nData);

3,271,030✔

3634

        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);

3,269,110✔

3635

        code = colDataSetVal(pColInfo, rowIndex, tmp, false);

3,275,331✔

3636

        taosMemoryFree(tmp);

3,275,942✔

3637

        QUERY_CHECK_CODE(code, lino, _end);

3,273,540✔

3639

        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);

9,908,359✔

3640

        QUERY_CHECK_CODE(code, lino, _end);

9,908,067✔

3645

_end:

25,101,155✔

3646

  if (code != TSDB_CODE_SUCCESS) {

25,101,155✔

3649

  return code;

25,095,813✔

3652

static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,

4,315,338✔

3654

  int32_t       code = TSDB_CODE_SUCCESS;

4,315,338✔

3655

  int32_t       lino = 0;

4,315,338✔

3656

  STagScanInfo* pInfo = pOperator->info;

4,315,338✔

3657

  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];

4,315,506✔

3658

  if (!ignoreFilterIdx) {

4,314,315✔

3659

    size_t szTables = taosArrayGetSize(aFilterIdxs);

1,369,786✔

3660

    for (int i = 0; i < szTables; ++i) {

3,285,205✔

3661

      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);

1,907,437✔

3662

      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);

1,910,525✔

3663

      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);

1,911,035✔

3664

      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

11,029,060✔

3665

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

9,110,210✔

3666

        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);

9,115,981✔

3667

        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);

9,115,981✔

3668

        QUERY_CHECK_CODE(code, lino, _end);

9,118,025✔

3672

    size_t szTables = taosArrayGetSize(aUidTags);

2,944,529✔

3673

    for (int i = 0; i < szTables; ++i) {

7,645,930✔

3674

      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);

4,702,443✔

3675

      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);

4,702,231✔

3676

      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {

20,674,327✔

3677

        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);

15,976,861✔

3678

        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);

15,979,856✔

3679

        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);

15,979,856✔

3680

        QUERY_CHECK_CODE(code, lino, _end);

15,971,934✔

3685

_end:

2,943,487✔

3686

  if (code != TSDB_CODE_SUCCESS) {

4,321,255✔

3689

  return code;

4,319,133✔

3692

static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

8,422,251✔

3693

  int32_t        code = TSDB_CODE_SUCCESS;

8,422,251✔

3694

  int32_t        lino = 0;

8,422,251✔

3695

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

8,422,251✔

3696

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

8,419,340✔

3698

  STagScanInfo* pInfo = pOperator->info;

8,419,957✔

3699

  SSDataBlock*  pRes = pInfo->pRes;

8,416,647✔

3701

  QRY_PARAM_CHECK(ppRes);

8,425,503✔

3703

  if (pOperator->status == OP_EXEC_DONE) {

8,425,844✔

3704

    return TSDB_CODE_SUCCESS;

4,041,258✔

3706

  blockDataCleanup(pRes);

4,374,674✔

3708

  if (pInfo->pCtbCursor == NULL) {

4,384,271✔

3709

    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);

4,386,674✔

3710

    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);

4,387,845✔

3712

    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);

735✔

3716

  SArray* aUidTags = pInfo->aUidTags;

4,387,239✔

3717

  SArray* aFilterIdxs = pInfo->aFilterIdxs;

4,388,575✔

3718

  int32_t count = 0;

4,386,483✔

3719

  bool    ctbCursorFinished = false;

4,386,483✔

3720

  while (1) {

96,322✔

3721

    taosArrayClearEx(aUidTags, tagScanFreeUidTag);

4,482,724✔

3722

    taosArrayClear(aFilterIdxs);

4,482,954✔

3724

    int32_t numTables = 0;

4,481,977✔

3725

    while (numTables < pOperator->resultInfo.capacity) {

11,241,871✔

3726

      SMCtbCursor* pCur = pInfo->pCtbCursor;

11,247,397✔

3727

      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);

11,245,584✔

3728

      if (uid == 0) {

11,241,708✔

3729

        ctbCursorFinished = true;

4,486,430✔

3730

        break;

4,486,430✔

3732

      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};

6,755,278✔

3733

      info.pTagVal = taosMemoryMalloc(pCur->vLen);

6,751,619✔

3734

      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);

6,753,924✔

3736

      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);

6,753,924✔

3737

      void* tmp = taosArrayPush(aUidTags, &info);

6,764,100✔

3738

      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

6,764,100✔

3739

      ++numTables;

6,764,100✔

3742

    if (numTables == 0) {

4,486,430✔

3743

      break;

165,881✔

3745

    bool ignoreFilterIdx = true;

4,320,549✔

3746

    if (pInfo->pTagCond != NULL) {

4,320,549✔

3747

      ignoreFilterIdx = false;

1,375,704✔

3748

      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);

1,375,704✔

3749

      QUERY_CHECK_CODE(code, lino, _end);

1,365,328✔

3751

      ignoreFilterIdx = true;

2,944,845✔

3754

    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);

4,310,173✔

3755

    QUERY_CHECK_CODE(code, lino, _end);

4,318,817✔

3757

    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);

4,318,817✔

3759

    if (count != 0) {

4,318,361✔

3760

      break;

4,222,120✔

3764

  if (count > 0) {

4,388,001✔

3765

    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);

4,223,418✔

3767

  if (count == 0 || ctbCursorFinished) {

4,388,420✔

3768

    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);

4,388,801✔

3769

    pInfo->pCtbCursor = NULL;

4,381,352✔

3770

    setOperatorCompleted(pOperator);

4,383,487✔

3773

  pRes->info.rows = count;

4,382,469✔

3774

  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);

4,382,469✔

3775

  if (bLimitReached) {

4,382,929✔

3779

  pOperator->resultInfo.totalRows += pRes->info.rows;

4,383,294✔

3780

  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;

4,382,600✔

3782

_end:

4,382,643✔

3783

  if (code != TSDB_CODE_SUCCESS) {

4,382,643✔

3789

  return code;

4,382,643✔

3792

static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {

3,564,015✔

3793

  STagScanInfo*          pInfo = pOperator->info;

3,564,015✔

3794

  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;

3,564,015✔

3795

  int32_t                code = 0;

3,564,015✔

3796

  STableListInfo*        pListInfo = pInfo->pTableListInfo;

3,564,015✔

3797

  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;

3,564,015✔

3798

  tb_uid_t               pUid = pParam->vcUid;

3,564,015✔

3804

  STableKeyInfo info = {.groupId = 0};

3,564,015✔

3806

  int32_t tableIdx = 0;

3,564,015✔

3807

  taosHashClear(pListInfo->map);

3,564,015✔

3808

  taosArrayClear(pListInfo->pTableList);

3,564,015✔

3810

  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {

3,564,015✔

3817

  info.uid = pUid;

3,564,015✔

3818

  void* p = taosArrayPush(pListInfo->pTableList, &info);

3,564,015✔

3819

  if (p == NULL) {

3,564,015✔

3823

  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));

3,564,015✔

3825

  return code;

3,564,015✔

3828

static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

7,644,809✔

3829

  int32_t       code = TSDB_CODE_SUCCESS;

7,644,809✔

3830

  int32_t       lino = 0;

7,644,809✔

3831

  STagScanInfo* pInfo = pOperator->info;

7,644,809✔

3832

  if (pOperator->pOperatorGetParam) {

7,645,288✔

3833

    pOperator->resultInfo.totalRows = 0;

3,564,015✔

3834

    pOperator->dynamicTask = true;

3,564,015✔

3835

    pInfo->curPos = 0;

3,564,015✔

3836

    code = createTagScanTableListInfoFromParam(pOperator);

3,564,015✔

3837

    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);

3,564,015✔

3838

    pOperator->pOperatorGetParam = NULL;

3,564,015✔

3839

    QUERY_CHECK_CODE(code, lino, _end);

3,564,015✔

3841

    if (pOperator->status == OP_EXEC_DONE) {

3,564,015✔

3842

      pOperator->status = OP_OPENED;

1,966,286✔

3846

  if (pOperator->status == OP_EXEC_DONE) {

7,644,799✔

3847

    (*ppRes) = NULL;

2,012,505✔

3848

    return code;

2,012,505✔

3851

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

5,629,809✔

3852

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

5,633,292✔

3854

  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];

5,631,805✔

3855

  SSDataBlock* pRes = pInfo->pRes;

5,630,308✔

3856

  blockDataCleanup(pRes);

5,628,811✔

3858

  int32_t size = 0;

5,631,795✔

3859

  code = tableListGetSize(pInfo->pTableListInfo, &size);

5,631,795✔

3860

  QUERY_CHECK_CODE(code, lino, _end);

5,630,767✔

3862

  if (size == 0) {

5,630,767✔

3863

    setTaskStatus(pTaskInfo, TASK_COMPLETED);

18,589✔

3864

    (*ppRes) = NULL;

18,589✔

3865

    return code;

18,589✔

3868

  SMetaReader mr = {0};

5,612,178✔

3869

  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);

5,613,668✔

3870

  pRes->info.rows = 0;

5,614,703✔

3872

  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {

16,202,036✔

3873

    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);

10,587,919✔

3874

    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&

10,590,359✔

3877

      code = TSDB_CODE_SUCCESS;

10,590,352✔

3879

    QUERY_CHECK_CODE(code, lino, _end);

10,590,359✔

3881

    if (++pInfo->curPos >= size) {

10,590,359✔

3882

      setOperatorCompleted(pOperator);

5,615,192✔

3886

  pAPI->metaReaderFn.clearReader(&mr);

5,617,142✔

3887

  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);

5,614,703✔

3888

  if (bLimitReached) {

5,615,192✔

3893

  if (pOperator->status == OP_EXEC_DONE) {

5,615,192✔

3894

    setTaskStatus(pTaskInfo, TASK_COMPLETED);

5,615,192✔

3897

  pOperator->resultInfo.totalRows += pRes->info.rows;

5,615,192✔

3899

  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;

5,614,703✔

3900

_end:

5,614,703✔

3901

  if (code != TSDB_CODE_SUCCESS) {

5,614,703✔

3906

  return code;

5,614,703✔

3909

static void destroyTagScanOperatorInfo(void* param) {

8,573,385✔

3910

  STagScanInfo* pInfo = (STagScanInfo*)param;

8,573,385✔

3911

  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {

8,573,385✔

3914

  taosHashCleanup(pInfo->filterCtx.colHash);

8,572,855✔

3915

  taosArrayDestroy(pInfo->filterCtx.cInfoList);

8,561,671✔

3916

  taosArrayDestroy(pInfo->aFilterIdxs);

8,559,262✔

3917

  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);

8,564,230✔

3919

  blockDataDestroy(pInfo->pRes);

8,572,598✔

3920

  taosArrayDestroy(pInfo->matchInfo.pList);

8,575,294✔

3921

  tableListDestroy(pInfo->pTableListInfo);

8,568,341✔

3923

  pInfo->pRes = NULL;

8,577,401✔

3924

  pInfo->pTableListInfo = NULL;

8,577,891✔

3925

  taosMemoryFreeClear(param);

8,578,524✔

3926

8,573,425✔

3928

static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {

4,718✔

3929

  int32_t         code = TSDB_CODE_SUCCESS;

4,718✔

3930

  STagScanInfo*   pInfo = pOper->info;

4,718✔

3932

  pOper->status = OP_NOT_OPENED;

4,718✔

3933

  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;

4,718✔

3934

  if (pTagScanNode->onlyMetaCtbIdx) {

4,718✔

3935

      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;

1,936✔

3936

      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

1,936✔

3937

      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);

1,936✔

3938

      pInfo->pCtbCursor = NULL;

1,936✔

3940

      pInfo->curPos = 0;

2,782✔

3943

  return code;

4,718✔

3946

int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,

8,570,857✔

3949

  QRY_PARAM_CHECK(pOptrInfo);

8,570,857✔

3951

  int32_t         code = TSDB_CODE_SUCCESS;

8,575,114✔

3952

  int32_t         lino = 0;

8,575,114✔

3953

  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;

8,575,114✔

3954

  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));

8,575,114✔

3955

  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

8,567,152✔

3956

  if (pInfo == NULL || pOperator == NULL) {

8,562,271✔

3960

  pOperator->pPhyNode = pTagScanNode;

8,562,271✔

3961

  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;

8,562,271✔

3963

  int32_t    numOfExprs = 0;

8,569,484✔

3964

  SExprInfo* pExprInfo = NULL;

8,568,892✔

3966

  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);

8,568,640✔

3967

  QUERY_CHECK_CODE(code, lino, _error);

8,576,063✔

3969

  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);

8,576,063✔

3970

  QUERY_CHECK_CODE(code, lino, _error);

8,551,482✔

3972

  int32_t num = 0;

8,551,482✔

3973

  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);

8,554,355✔

3974

  QUERY_CHECK_CODE(code, lino, _error);

8,571,577✔

3976

  pInfo->pTagCond = pTagCond;

8,571,577✔

3977

  pInfo->pTagIndexCond = pTagIndexCond;

8,573,517✔

3978

  pInfo->suid = pPhyNode->suid;

8,570,457✔

3979

  pInfo->pStorageAPI = &pTaskInfo->storageAPI;

8,568,588✔

3981

  pInfo->pTableListInfo = pTableListInfo;

8,563,841✔

3982

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

8,573,659✔

3983

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

8,579,119✔

3985

  pInfo->readHandle = *pReadHandle;

8,551,936✔

3986

  pInfo->curPos = 0;

8,571,499✔

3988

  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);

8,538,329✔

3989

  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,

8,541,545✔

3991

  initResultSizeInfo(&pOperator->resultInfo, 4096);

8,545,120✔

3992

  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);

8,541,607✔

3993

  QUERY_CHECK_CODE(code, lino, _error);

8,577,649✔

3995

  if (pTagScanNode->onlyMetaCtbIdx) {

8,577,649✔

3996

    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));

4,564,362✔

3997

    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);

4,565,762✔

3999

    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));

4,565,074✔

4000

    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);

4,565,833✔

4002

    pInfo->filterCtx.colHash =

4,565,039✔

4003

        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);

4,565,139✔

4004

    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);

4,565,876✔

4006

    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));

4,563,741✔

4007

    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);

4,563,452✔

4009

    if (pInfo->pTagCond != NULL) {

4,563,469✔

4010

      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);

1,378,044✔

4013

  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;

8,578,945✔

4014

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,

8,578,814✔

4016

  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);

8,569,152✔

4018

  *pOptrInfo = pOperator;

8,571,031✔

4019

  return code;

8,571,618✔

4036

static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {

230,509,008✔

4037

  int32_t                 left = *(int32_t*)pLeft;

230,509,008✔

4038

  int32_t                 right = *(int32_t*)pRight;

230,509,008✔

4039

  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;

230,509,008✔

4041

  int32_t leftIdx = pInfo->aInputs[left].rowIdx;

230,509,008✔

4042

  int32_t rightIdx = pInfo->aInputs[right].rowIdx;

230,509,008✔

4044

  if (leftIdx == -1) {

230,509,008✔

4045

    return 1;

197,445,648✔

4046

  } else if (rightIdx == -1) {

33,063,360✔

4047

    return -1;

327,360✔

4050

  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];

32,736,000✔

4051

  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];

32,736,000✔

4052

  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);

32,736,000✔

4053

  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {

32,736,000✔

4056

  return ret;

32,736,000✔

4086

int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {

2,907,764✔

4087

  int32_t code = TSDB_CODE_SUCCESS;

2,907,764✔

4088

  int32_t lino = 0;

2,907,764✔

4089

  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));

2,907,764✔

4090

  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));

2,907,764✔

4091

  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);

2,900,603✔

4092

  for (int i = 0; i < src->numOfCols; i++) {

9,486,836✔

4093

    dst->colList[i] = src->colList[i];

6,619,065✔

4096

_end:

2,900,950✔

4097

  if (code != TSDB_CODE_SUCCESS) {

2,900,950✔

4100

  return code;

2,894,076✔

4103

static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,

4,386,159✔

4105

  int32_t code = 0;

4,386,159✔

4107

  STableMergeScanInfo*    pInfo = pOperator->info;

4,386,159✔

4108

  SReadHandle*            pHandle = &pInfo->base.readHandle;

4,383,443✔

4109

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

4,376,904✔

4110

  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;

4,379,644✔

4111

  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;

4,381,361✔

4113

  blockDataCleanup(pInput->pReaderBlock);

4,385,824✔

4114

  if (!pInput->bInMemReader) {

4,374,858✔

4115

    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,

4,382,566✔

4116

                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);

2,194,705✔

4117

    if (code != 0) {

2,196,069✔

4122

  pInfo->base.dataReader = pInput->pReader;

4,377,251✔

4124

  while (true) {

8,675✔

4125

    bool hasNext = false;

4,389,689✔

4126

    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);

4,390,024✔

4127

    if (code != 0) {

4,397,951✔

4133

    if (!hasNext || isTaskKilled(pTaskInfo)) {

4,397,951✔

4134

      if (isTaskKilled(pTaskInfo)) {

2,930,019✔

4140

      *pSubTableHasBlock = false;

2,932,059✔

4141

      break;

2,930,701✔

4144

    if (pInput->tblCond.order == TSDB_ORDER_ASC) {

1,467,932✔

4145

      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;

1,443,642✔

4147

      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;

24,290✔

4150

    uint32_t status = 0;

1,467,932✔

4151

    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);

1,467,932✔

4152

    if (code != 0) {

1,467,932✔

4157

    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

1,467,932✔

4161

    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {

1,467,932✔

4162

      continue;

8,675✔

4165

    *pSubTableHasBlock = true;

1,459,257✔

4166

    break;

1,459,257✔

4169

  if (*pSubTableHasBlock) {

4,390,640✔

4170

    pInput->pReaderBlock->info.id.groupId =

2,917,820✔

4171

        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);

2,918,167✔

4172

    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;

1,459,257✔

4174

  if (!pInput->bInMemReader || !*pSubTableHasBlock) {

4,390,646✔

4175

    pAPI->tsdReader.tsdReaderClose(pInput->pReader);

3,300,764✔

4176

    pInput->pReader = NULL;

3,295,619✔

4179

  pInfo->base.dataReader = NULL;

4,387,206✔

4180

  return TSDB_CODE_SUCCESS;

4,385,495✔

4183

static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {

1,799,007✔

4184

  pInfo->bGroupProcessed = false;

1,799,007✔

4186

  int32_t numOfTables = 0;

1,812,354✔

4187

  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

1,791,104✔

4188

  if (code != TSDB_CODE_SUCCESS) {

1,760,671✔

4193

  int32_t i = pInfo->tableStartIndex + 1;

1,760,671✔

4194

  for (; i < numOfTables; ++i) {

2,861,543✔

4195

    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);

1,149,169✔

4196

    if (!tableKeyInfo) {

1,148,822✔

4200

    if (tableKeyInfo->groupId != pInfo->groupId) {

1,148,822✔

4201

      break;

54,453✔

4204

  pInfo->tableEndIndex = i - 1;

1,766,827✔

4205

  return TSDB_CODE_SUCCESS;

1,816,727✔

4208

static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {

1,832,162✔

4209

  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

4,763,533✔

4210

    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

2,931,383✔

4211

    if (pInput->rowIdx == -1) {

2,928,302✔

4212

      continue;

1,470,421✔

4215

    if (pInput->type == SUB_TABLE_MEM_BLOCK) {

1,459,257✔

4216

      pInput->rowIdx = 0;

1,458,569✔

4217

      pInput->pageIdx = -1;

1,458,569✔

4220

    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

1,459,604✔

4221

    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);

1,458,916✔

4222

    if (!col) {

1,458,910✔

4226

    pInput->aTs = (int64_t*)col->pData;

1,458,910✔

4229

  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;

1,833,867✔

4230

  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);

1,834,208✔

4233

static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {

1,811,977✔

4234

  int32_t code = setGroupStartEndIndex(pInfo);

1,811,977✔

4235

  if (code != TSDB_CODE_SUCCESS) {

1,809,506✔

4239

  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));

1,809,506✔

4240

  if (pSubTblsInfo == NULL) {

1,785,594✔

4243

  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);

1,785,594✔

4244

  if (!pSubTblsInfo->pTsOrderInfo) {

1,797,589✔

4248

  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {

1,795,232✔

4255

    pSubTblsInfo->pPkOrderInfo = NULL;

1,775,699✔

4257

  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;

1,809,961✔

4258

  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));

1,770,237✔

4259

  if (pSubTblsInfo->aInputs == NULL) {

1,778,421✔

4263

  int32_t bufPageSize = pInfo->bufPageSize;

1,780,455✔

4264

  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;

1,806,515✔

4265

  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);

1,810,272✔

4266

  if (code != TSDB_CODE_SUCCESS) {

1,774,006✔

4271

  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;

1,774,006✔

4272

  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;

1,814,729✔

4274

  pInfo->pSubTablesMergeInfo = pSubTblsInfo;

1,807,508✔

4275

  return TSDB_CODE_SUCCESS;

1,790,739✔

4278

static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {

1,802,710✔

4279

  int32_t        code = TSDB_CODE_SUCCESS;

1,802,710✔

4280

  int32_t        lino = 0;

1,802,710✔

4281

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

1,802,710✔

4282

  SReadHandle*   pHandle = &pInfo->base.readHandle;

1,800,706✔

4283

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

1,808,555✔

4285

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

1,801,113✔

4287

  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

4,720,429✔

4288

    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

2,906,789✔

4289

    pInput->type = SUB_TABLE_MEM_BLOCK;

2,893,717✔

4291

    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);

2,911,545✔

4292

    QUERY_CHECK_CODE(code, lino, _end);

2,885,551✔

4294

    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);

2,885,551✔

4295

    QUERY_CHECK_CODE(code, lino, _end);

2,930,701✔

4297

    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);

2,930,701✔

4298

    QUERY_CHECK_CODE(code, lino, _end);

2,931,724✔

4300

    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);

2,931,724✔

4301

    pInput->pKeyInfo = keyInfo;

2,930,013✔

4303

    if (isTaskKilled(pTaskInfo)) {

2,925,891✔

4307

    if (i + 1 < pSubTblsInfo->numInMemReaders) {

2,916,307✔

4308

      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,

2,192,902✔

4309

                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);

1,097,492✔

4310

      QUERY_CHECK_CODE(code, lino, _end);

1,097,492✔

4311

      pInput->bInMemReader = true;

1,097,492✔

4313

      pInput->pReader = NULL;

1,829,422✔

4314

      pInput->bInMemReader = false;

1,829,428✔

4316

    bool hasNext = true;

2,924,491✔

4317

    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);

2,924,455✔

4318

    QUERY_CHECK_CODE(code, lino, _end);

2,928,990✔

4319

    if (!hasNext) {

2,928,990✔

4320

      pInput->rowIdx = -1;

1,469,733✔

4321

      ++pSubTblsInfo->numSubTablesCompleted;

1,470,074✔

4322

      continue;

1,471,097✔

4324

      pInput->rowIdx = 0;

1,459,257✔

4325

      pInput->pageIdx = -1;

1,458,910✔

4329

_end:

1,829,087✔

4330

  if (code != TSDB_CODE_SUCCESS) {

1,829,087✔

4333

  return code;

1,830,792✔

4336

static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {

1,459,257✔

4337

  int32_t              code = TSDB_CODE_SUCCESS;

1,459,257✔

4338

  int32_t              lino = 0;

1,459,257✔

4339

  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;

1,459,257✔

4340

  STableMergeScanInfo* pInfo = pOperatorInfo->info;

1,459,257✔

4341

  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

1,459,257✔

4342

  bool                 hasNext = true;

1,459,257✔

4343

  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);

1,459,257✔

4344

  QUERY_CHECK_CODE(code, lino, _end);

1,459,257✔

4346

  if (!hasNext) {

1,459,257✔

4347

    pInput->rowIdx = -1;

1,459,257✔

4348

    ++pSubTblsInfo->numSubTablesCompleted;

1,459,257✔

4353

_end:

1,458,910✔

4354

  if (code != TSDB_CODE_SUCCESS) {

1,459,257✔

4359

1,459,257✔

4361

static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {

266,008,226✔

4362

  STableMergeScanInfo* pInfo = pOperatorInfo->info;

266,008,226✔

4363

  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

266,010,643✔

4365

  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

266,005,504✔

4366

  if (pInput->rowIdx < pInputBlock->info.rows - 1) {

266,048,441✔

4367

    ++pInput->rowIdx;

264,584,398✔

4368

  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {

1,459,257✔

4369

    if (pInput->type == SUB_TABLE_MEM_BLOCK) {

1,459,257✔

4370

      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);

1,459,257✔

4372

    if (pInput->rowIdx != -1) {

1,459,257✔

4383

  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));

266,043,643✔

4386

static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {

265,718,191✔

4387

  int32_t            code = TSDB_CODE_SUCCESS;

265,718,191✔

4388

  int32_t            lino = 0;

265,718,191✔

4389

  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);

265,718,191✔

4390

  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;

265,789,245✔

4392

  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {

1,088,648,909✔

4393

    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);

821,834,018✔

4394

    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);

822,012,521✔

4396

    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);

822,012,521✔

4397

    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);

821,271,462✔

4398

    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);

821,271,462✔

4400

    if (isNull) {

821,838,812✔

4401

      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);

84,362,027✔

4402

      QUERY_CHECK_CODE(code, lino, _end);

84,348,141✔

4404

      if (pSrcColInfo->pData != NULL) {

737,476,785✔

4405

        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);

737,672,867✔

4406

        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);

738,833,485✔

4407

        QUERY_CHECK_CODE(code, lino, _end);

738,455,454✔

4411

  pBlock->info.dataLoad = 1;

266,014,729✔

4412

  pBlock->info.scanFlag = pInputBlock->info.scanFlag;

266,015,070✔

4413

  pBlock->info.rows += 1;

266,016,105✔

4415

_end:

266,015,459✔

4416

  if (code != TSDB_CODE_SUCCESS) {

266,015,459✔

4419

  return code;

266,013,389✔

4422

static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,

2,965,423✔

4424

  int32_t                 code = TSDB_CODE_SUCCESS;

2,965,423✔

4425

  int32_t                 lino = 0;

2,965,423✔

4426

  STableMergeScanInfo*    pInfo = pOperator->info;

2,965,423✔

4427

  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;

2,964,059✔

4428

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

2,965,082✔

4429

  bool                    finished = false;

2,962,013✔

4431

  QRY_PARAM_CHECK(pResBlock);

2,962,013✔

4433

  blockDataCleanup(pBlock);

2,954,152✔

4437

      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {

268,694,425✔

4438

        finished = true;

2,964,059✔

4439

        break;

2,964,059✔

4442

      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);

265,731,347✔

4443

      QUERY_CHECK_CODE(code, lino, _end);

266,006,551✔

4445

      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);

266,006,551✔

4446

      QUERY_CHECK_CODE(code, lino, _end);

265,735,822✔

4448

      if (pBlock->info.rows >= capacity) {

265,735,822✔

4453

    if (isTaskKilled(pTaskInfo)) {

2,964,059✔

4457

    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);

2,964,741✔

4458

    if (finished || limitReached || pBlock->info.rows > 0) {

2,963,377✔

4463

  if (pBlock->info.rows > 0) {

2,963,377✔

4464

    *pResBlock = pBlock;

1,131,897✔

4467

_end:

1,833,526✔

4468

  if (code != TSDB_CODE_SUCCESS) {

2,965,423✔

4472

  return code;

2,964,741✔

4475

static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {

1,812,306✔

4476

  int32_t              code = TSDB_CODE_SUCCESS;

1,812,306✔

4477

  int32_t              lino = 0;

1,812,306✔

4478

  STableMergeScanInfo* pInfo = pOperator->info;

1,812,306✔

4480

  code = initSubTablesMergeInfo(pInfo);

1,813,712✔

4481

  QUERY_CHECK_CODE(code, lino, _end);

1,777,751✔

4483

  code = initSubTableInputs(pOperator, pInfo);

1,777,751✔

4484

  QUERY_CHECK_CODE(code, lino, _end);

1,831,139✔

4486

  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);

1,831,139✔

4487

  QUERY_CHECK_CODE(code, lino, _end);

1,826,365✔

4489

_end:

1,826,365✔

4490

  if (code != TSDB_CODE_SUCCESS) {

1,826,365✔

4493

  return code;

1,828,752✔

4496

static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {

29,368,381✔

4497

  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;

29,368,381✔

4498

  if (pSubTblsInfo != NULL) {

29,376,091✔

4499

    tMergeTreeDestroy(&pSubTblsInfo->pTree);

1,832,844✔

4501

    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {

4,758,424✔

4502

      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;

2,932,065✔

4503

      taosMemoryFree(pInput->tblCond.colList);

2,927,973✔

4504

      blockDataDestroy(pInput->pReaderBlock);

2,927,291✔

4505

      blockDataDestroy(pInput->pPageBlock);

2,932,059✔

4506

      taosArrayDestroy(pInput->aBlockPages);

2,930,360✔

4507

      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);

2,930,701✔

4508

      pInput->pReader = NULL;

2,929,331✔

4511

    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);

1,831,133✔

4512

    taosMemoryFree(pSubTblsInfo->aInputs);

1,830,792✔

4514

    taosMemoryFree(pSubTblsInfo);

1,830,445✔

4515

    pInfo->pSubTablesMergeInfo = NULL;

1,829,769✔

4519

29,373,016✔

4521

int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

2,936,595✔

4522

  QRY_PARAM_CHECK(ppRes);

2,936,595✔

4524

  int32_t lino = 0;

2,931,175✔

4525

  int32_t tableListSize = 0;

2,931,175✔

4526

  int64_t st = taosGetTimestampUs();

2,929,081✔

4528

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

2,929,081✔

4529

  STableMergeScanInfo* pInfo = pOperator->info;

2,936,272✔

4531

  if (pOperator->status == OP_EXEC_DONE) {

2,944,845✔

4535

  int32_t code = pOperator->fpSet._openFn(pOperator);

2,897,966✔

4536

  QUERY_CHECK_CODE(code, lino, _end);

2,933,197✔

4538

  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);

2,933,197✔

4539

  QUERY_CHECK_CODE(code, lino, _end);

2,934,208✔

4541

  if (!pInfo->hasGroupId) {

2,934,208✔

4542

    pInfo->hasGroupId = true;

1,802,293✔

4544

    if (tableListSize == 0) {

1,773,230✔

4545

      setOperatorCompleted(pOperator);

46,498✔

4546

      (*ppRes) = NULL;

47,192✔

4547

      return code;

47,192✔

4550

    pInfo->tableStartIndex = 0;

1,726,732✔

4551

    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

1,713,044✔

4552

    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);

1,719,906✔

4553

    pInfo->groupId = pTmpGpId->groupId;

1,719,906✔

4554

    code = startSubTablesTableMergeScan(pOperator);

1,755,825✔

4555

    QUERY_CHECK_CODE(code, lino, _end);

1,774,634✔

4558

  SSDataBlock* pBlock = NULL;

2,908,254✔

4559

  while (pInfo->tableStartIndex < tableListSize) {

2,960,984✔

4560

    if (isTaskKilled(pTaskInfo)) {

2,962,695✔

4564

    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);

2,961,660✔

4565

    QUERY_CHECK_CODE(code, lino, _end);

2,964,741✔

4567

    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {

2,964,741✔

4574

    if (pBlock != NULL) {

2,965,082✔

4575

      pBlock->info.id.groupId = pInfo->groupId;

1,131,897✔

4576

      pOperator->resultInfo.totalRows += pBlock->info.rows;

1,131,897✔

4577

      pInfo->bGroupProcessed = true;

1,131,897✔

4578

      break;

1,131,897✔

4581

      stopSubTablesTableMergeScan(pInfo);

1,833,185✔

4582

      if (pInfo->tableEndIndex >= tableListSize - 1) {

1,831,821✔

4583

        setOperatorCompleted(pOperator);

1,775,657✔

4584

        break;

1,777,021✔

4587

      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;

54,800✔

4588

      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

54,106✔

4589

      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);

54,800✔

4591

      pInfo->groupId = pTmpGpId->groupId;

54,800✔

4592

      code = startSubTablesTableMergeScan(pOperator);

54,106✔

4593

      QUERY_CHECK_CODE(code, lino, _end);

54,800✔

4594

      resetLimitInfoForNextGroup(&pInfo->limitInfo);

54,800✔

4598

  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;

2,908,912✔

4600

_end:

2,904,820✔

4601

  if (code != TSDB_CODE_SUCCESS) {

2,909,600✔

4606

    (*ppRes) = pBlock;

2,909,600✔

4609

  return code;

2,909,259✔

4612

static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {

3,330,783✔

4613

  int32_t              code = TSDB_CODE_SUCCESS;

3,330,783✔

4614

  int32_t              lino = 0;

3,330,783✔

4615

  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;

3,330,783✔

4616

  STableMergeScanInfo* pInfo = pOperator->info;

3,330,783✔

4617

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

3,330,783✔

4619

  if (pInfo->mSkipTables == NULL) {

3,330,783✔

4620

    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,

301,076✔

4622

    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);

301,076✔

4624

  int bSkip = 1;

3,330,783✔

4625

  if (pInfo->mSkipTables != NULL) {

3,330,783✔

4626

    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));

3,330,783✔

4627

    if (code == TSDB_CODE_DUP_KEY) {

3,330,783✔

4630

    QUERY_CHECK_CODE(code, lino, _end);

3,330,783✔

4633

_end:

3,330,783✔

4634

  if (code != TSDB_CODE_SUCCESS) {

3,330,783✔

4639

3,330,783✔

4641

static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {

154,776,658✔

4642

  STableMergeScanInfo* pInfo = pOperator->info;

154,776,658✔

4643

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

154,792,475✔

4644

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

154,769,498✔

4645

  SSDataBlock*         pBlock = pInfo->pReaderBlock;

154,787,590✔

4646

  int32_t              code = 0;

154,758,500✔

4647

  bool                 hasNext = false;

154,758,500✔

4648

  STsdbReader*         reader = pInfo->base.dataReader;

154,753,753✔

4650

  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);

154,751,588✔

4651

  if (code != 0) {

154,763,975✔

4658

  if (!hasNext || isTaskKilled(pTaskInfo)) {

154,763,975✔

4659

    if (isTaskKilled(pTaskInfo)) {

28,834,141✔

4660

      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));

73✔

4661

      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);

73✔

4663

    *pFinished = true;

28,817,215✔

4664

    return code;

28,816,612✔

4667

  uint32_t status = 0;

125,937,208✔

4668

  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);

125,945,216✔

4670

  if (code != TSDB_CODE_SUCCESS) {

125,939,987✔

4671

    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));

64,962✔

4672

    pTaskInfo->code = code;

61,640✔

4673

    return code;

61,640✔

4676

  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {

125,875,027✔

4682

  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {

125,875,027✔

4683

    *pSkipped = true;

5,271,617✔

4684

    return code;

5,293,512✔

4687

  return code;

120,590,186✔

4690

static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {

152,517,100✔

4691

  STableMergeScanSortSourceParam* source = param;

152,517,100✔

4693

  SOperatorInfo*       pOperator = source->pOperator;

152,517,100✔

4694

  STableMergeScanInfo* pInfo = pOperator->info;

152,522,688✔

4695

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

152,516,240✔

4696

  SSDataBlock*         pBlock = NULL;

152,504,790✔

4697

  int64_t              st = taosGetTimestampUs();

152,515,192✔

4698

  int32_t              code = TSDB_CODE_SUCCESS;

152,515,192✔

4701

    if (pInfo->rtnNextDurationBlocks) {

160,748,806✔

4702

      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",

5,975,482✔

4705

      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {

5,975,873✔

4706

        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];

2,936,954✔

4707

        ++pInfo->nextDurationBlocksIdx;

2,936,954✔

4709

        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {

5,974,843✔

4710

          blockDataDestroy(pInfo->nextDurationBlocks[i]);

2,935,924✔

4711

          pInfo->nextDurationBlocks[i] = NULL;

2,935,924✔

4714

        pInfo->rtnNextDurationBlocks = false;

3,038,919✔

4715

        pInfo->nextDurationBlocksIdx = 0;

3,038,919✔

4716

        pInfo->numNextDurationBlocks = 0;

3,038,919✔

4717

        continue;

3,038,919✔

4720

      bool bFinished = false;

154,779,112✔

4721

      bool bSkipped = false;

154,758,389✔

4723

      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);

154,800,460✔

4724

      if (code != 0) {

154,745,058✔

4725

        return code;

61,640✔

4728

      pBlock = pInfo->pReaderBlock;

154,683,418✔

4729

      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",

154,696,201✔

4731

      if (bFinished) {

154,730,206✔

4732

        pInfo->bNewFilesetEvent = false;

28,824,091✔

4733

        break;

28,819,733✔

4736

      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {

125,906,115✔

4737

        if (!bSkipped) {

3,036,336✔

4738

          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);

2,936,954✔

4739

          if (code) {

2,935,431✔

4744

          ++pInfo->numNextDurationBlocks;

2,935,431✔

4745

          if (pInfo->numNextDurationBlocks > 2) {

2,935,431✔

4753

        if (pInfo->bNewFilesetEvent) {

3,036,336✔

4754

          pInfo->rtnNextDurationBlocks = true;

3,038,426✔

4755

          *ppBlock = NULL;

3,039,167✔

4756

          return code;

3,039,558✔

4761

          continue;

47,161✔

4764

      if (bSkipped) continue;

122,867,711✔

4767

    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);

120,609,970✔

4769

    pOperator->resultInfo.totalRows += pBlock->info.rows;

120,622,594✔

4770

    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

120,621,549✔

4771

    *ppBlock = pBlock;

120,622,571✔

4773

    return code;

120,622,073✔

4776

  *ppBlock = NULL;

28,822,208✔

4777

  return code;

28,826,618✔

4780

int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {

25,197,639✔

4781

  int32_t code = TSDB_CODE_SUCCESS;

25,197,639✔

4782

  int32_t lino = 0;

25,197,639✔

4783

  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));

25,197,639✔

4784

  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);

25,147,580✔

4785

  SBlockOrderInfo biTs = {0};

25,161,938✔

4786

  SBlockOrderInfo biPk = {0};

25,160,329✔

4788

  int32_t tsTargetSlotId = 0;

25,155,687✔

4789

  int32_t pkTargetSlotId = -1;

25,155,687✔

4790

  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {

90,887,450✔

4791

    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);

65,844,669✔

4792

    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);

65,865,189✔

4793

    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {

65,858,878✔

4794

      tsTargetSlotId = colInfo->dstSlotId;

25,204,671✔

4795

      biTs.order = order;

25,206,773✔

4796

      biTs.slotId = tsTargetSlotId;

25,206,773✔

4797

      biTs.nullFirst = (order == TSDB_ORDER_ASC);

25,206,773✔

4798

      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);

25,206,773✔

4801

    if (colInfo->isPk) {

65,815,202✔

4802

      pkTargetSlotId = colInfo->dstSlotId;

1,775,211✔

4803

      biPk.order = order;

1,775,825✔

4804

      biPk.slotId = pkTargetSlotId;

1,775,825✔

4805

      biPk.nullFirst = (order == TSDB_ORDER_ASC);

1,775,825✔

4806

      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);

1,775,825✔

4810

  void* tmp = taosArrayPush(pSortInfo, &biTs);

25,212,373✔

4811

  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

25,212,373✔

4812

  if (pkTargetSlotId != -1) {

25,212,373✔

4813

    tmp = taosArrayPush(pSortInfo, &biPk);

1,776,393✔

4814

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

1,776,393✔

4817

  (*ppSortArray) = pSortInfo;

25,213,578✔

4819

_end:

25,176,300✔

4820

  if (code != TSDB_CODE_SUCCESS) {

25,184,293✔

4823

  return code;

25,178,135✔

4826

void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {

4,348,639✔

4827

  STableMergeScanInfo* pTmsInfo = param;

4,348,639✔

4828

  if (type == TSD_READER_NOTIFY_DURATION_START) {

4,348,639✔

4829

    pTmsInfo->bNewFilesetEvent = true;

4,349,339✔

4833

  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);

4,345,961✔

4835

  return;

4,350,444✔

4838

int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {

32,051,760✔

4839

  STableMergeScanInfo* pInfo = pOperator->info;

32,051,760✔

4840

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

32,080,318✔

4842

  int32_t code = TSDB_CODE_SUCCESS;

32,061,728✔

4843

  int32_t lino = 0;

32,061,728✔

4844

  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;

32,061,728✔

4846

  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));

32,029,870✔

4847

  pInfo->bNewFilesetEvent = false;

32,060,334✔

4848

  pInfo->bNextDurationBlockEvent = false;

32,088,324✔

4850

  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;

32,071,633✔

4851

  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;

32,078,234✔

4853

  pInfo->pSortHandle = NULL;

32,070,689✔

4854

  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,

61,565,399✔

4855

                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);

32,045,574✔

4856

  if (code) {

32,014,655✔

4860

  if (pInfo->bSortRowId && numOfTable != 1) {

32,014,655✔

4861

    int32_t memSize = 512 * 1024 * 1024;

1,570,571✔

4862

    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);

1,570,571✔

4863

    QUERY_CHECK_CODE(code, lino, _end);

1,570,571✔

4866

  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);

32,020,054✔

4867

  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);

32,018,948✔

4868

  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);

31,986,904✔

4870

  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);

31,968,776✔

4871

  QUERY_CHECK_CODE(code, lino, _end);

32,007,441✔

4873

  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));

32,007,441✔

4874

  QUERY_CHECK_NULL(param, code, lino, _end, terrno);

32,014,519✔

4875

  param->pOperator = pOperator;

32,014,519✔

4877

  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));

32,041,319✔

4878

  if (ps == NULL) {

32,006,971✔

4883

  ps->param = param;

32,006,971✔

4884

  ps->onlyRef = false;

32,051,791✔

4885

  code = tsortAddSource(pInfo->pSortHandle, ps);

32,065,038✔

4886

  QUERY_CHECK_CODE(code, lino, _end);

32,038,570✔

4888

  if (numOfTable == 1) {

32,038,570✔

4889

    tsortSetSingleTableMerge(pInfo->pSortHandle);

22,355,493✔

4891

    code = tsortOpen(pInfo->pSortHandle);

9,683,077✔

4892

    QUERY_CHECK_CODE(code, lino, _end);

9,732,851✔

4895

_end:

9,702,023✔

4896

  if (code != TSDB_CODE_SUCCESS) {

32,076,734✔

4897

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

30,828✔

4899

  return code;

32,091,217✔

4902

void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {

32,057,934✔

4903

  STableMergeScanInfo* pInfo = pOperator->info;

32,057,934✔

4904

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

32,058,424✔

4905

  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));

32,055,484✔

4907

  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);

32,056,079✔

4908

  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;

32,047,062✔

4909

  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;

32,048,017✔

4910

  pInfo->sortExecInfo.loops += sortExecInfo.loops;

32,049,862✔

4911

  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;

32,053,432✔

4912

  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;

32,050,790✔

4914

  tsortDestroySortHandle(pInfo->pSortHandle);

32,050,440✔

4915

  pInfo->pSortHandle = NULL;

32,051,908✔

4916

32,049,483✔

4918

void startGroupTableMergeScan(SOperatorInfo* pOperator) {

28,998,816✔

4919

  int32_t              code = TSDB_CODE_SUCCESS;

28,998,816✔

4920

  int32_t              lino = 0;

28,998,816✔

4921

  STableMergeScanInfo* pInfo = pOperator->info;

28,998,816✔

4922

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

29,004,822✔

4923

  SReadHandle*         pHandle = &pInfo->base.readHandle;

28,973,102✔

4924

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

28,946,433✔

4925

  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);

28,991,162✔

4928

    int32_t numOfTables = 0;

28,996,874✔

4929

    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);

28,950,203✔

4930

    QUERY_CHECK_CODE(code, lino, _end);

28,991,781✔

4932

    int32_t i = pInfo->tableStartIndex + 1;

28,991,781✔

4933

    for (; i < numOfTables; ++i) {

131,961,927✔

4934

      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);

109,048,940✔

4935

      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);

109,046,916✔

4936

      if (tableKeyInfo->groupId != pInfo->groupId) {

109,047,078✔

4937

        break;

6,076,584✔

4940

    pInfo->tableEndIndex = i - 1;

28,989,571✔

4942

  pInfo->bGroupProcessed = false;

29,019,646✔

4943

  int32_t tableStartIdx = pInfo->tableStartIndex;

29,023,420✔

4944

  int32_t tableEndIdx = pInfo->tableEndIndex;

29,009,953✔

4946

  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;

29,024,896✔

4947

  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);

29,024,896✔

4948

  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,

55,446,567✔

4949

                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);

29,013,212✔

4950

  QUERY_CHECK_CODE(code, lino, _end);

29,022,044✔

4951

  if (pInfo->filesetDelimited) {

29,022,044✔

4952

    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);

29,032,374✔

4954

  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);

29,042,164✔

4956

  code = startDurationForGroupTableMergeScan(pOperator);

28,976,645✔

4957

  QUERY_CHECK_CODE(code, lino, _end);

29,024,986✔

4959

_end:

28,994,158✔

4960

  if (code != TSDB_CODE_SUCCESS) {

29,026,829✔

4961

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

30,828✔

4962

    pTaskInfo->code = code;

30,828✔

4963

    T_LONG_JMP(pTaskInfo->env, code);

30,828✔

4965

28,996,001✔

4967

void stopGroupTableMergeScan(SOperatorInfo* pOperator) {

29,017,488✔

4968

  STableMergeScanInfo* pInfo = pOperator->info;

29,017,488✔

4969

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

29,018,958✔

4970

  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;

29,017,733✔

4972

  stopDurationForGroupTableMergeScan(pOperator);

29,016,483✔

4974

  if (pInfo->base.dataReader != NULL) {

29,009,946✔

4975

    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);

29,013,376✔

4976

    pInfo->base.dataReader = NULL;

28,983,422✔

4978

  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {

28,984,777✔

4979

    if (pInfo->nextDurationBlocks[i]) {

1,030✔

4980

      blockDataDestroy(pInfo->nextDurationBlocks[i]);

1,030✔

4981

      pInfo->nextDurationBlocks[i] = NULL;

1,030✔

4983

    pInfo->numNextDurationBlocks = 0;

1,030✔

4984

    pInfo->nextDurationBlocksIdx = 0;

1,030✔

4986

  resetLimitInfoForNextGroup(&pInfo->limitInfo);

28,998,015✔

4987

  taosHashCleanup(pInfo->mSkipTables);

28,938,549✔

4988

  pInfo->mSkipTables = NULL;

28,964,471✔

4989

  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);

28,969,106✔

4990

29,007,592✔

4994

SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,

65,162,174✔

4996

  STableMergeScanInfo* pInfo = pOperator->info;

65,162,174✔

4997

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

65,175,780✔

4998

  STupleHandle*        pTupleHandle = NULL;

65,162,827✔

5000

  blockDataCleanup(pResBlock);

65,178,470✔

5003

    while (1) {

2,147,483,647✔

5004

      pTupleHandle = NULL;

2,147,483,647✔

5005

      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);

2,147,483,647✔

5006

      if (code != TSDB_CODE_SUCCESS) {

2,147,483,647✔

5007

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

3,830,257✔

5008

        T_LONG_JMP(pOperator->pTaskInfo->env, code);

3,830,257✔

5010

      if (pTupleHandle == NULL) {

2,147,483,647✔

5011

        break;

53,063,738✔

5014

      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);

2,147,483,647✔

5015

      if (code != TSDB_CODE_SUCCESS) {

2,147,483,647✔

5016

        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));

2✔

5017

        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);

2✔

5020

      if (pResBlock->info.rows >= capacity) {

2,147,483,647✔

5021

        break;

12,094,236✔

5025

    if (tsortIsClosed(pHandle)) {

65,157,974✔

5030

    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);

65,165,303✔

5031

    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,

65,164,992✔

5033

    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {

65,168,227✔

5037

  return (pResBlock->info.rows > 0) ? pResBlock : NULL;

65,168,227✔

5040

int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

58,792,718✔

5041

  if (pOperator->status == OP_EXEC_DONE) {

58,792,718✔

5042

    (*ppRes) = NULL;

40,769✔

5043

    return TSDB_CODE_SUCCESS;

40,769✔

5046

  int32_t              code = TSDB_CODE_SUCCESS;

58,740,375✔

5047

  int32_t              lino = 0;

58,740,375✔

5048

  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;

58,740,375✔

5049

  STableMergeScanInfo* pInfo = pOperator->info;

58,759,479✔

5051

  code = pOperator->fpSet._openFn(pOperator);

58,734,197✔

5052

  QUERY_CHECK_CODE(code, lino, _end);

58,688,863✔

5054

  int64_t st = taosGetTimestampUs();

58,746,956✔

5056

  int32_t tableListSize = 0;

58,746,956✔

5057

  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);

58,745,342✔

5058

  QUERY_CHECK_CODE(code, lino, _end);

58,746,044✔

5060

  if (!pInfo->hasGroupId) {

58,746,044✔

5061

    pInfo->hasGroupId = true;

25,648,721✔

5063

    if (tableListSize == 0) {

25,590,973✔

5064

      setOperatorCompleted(pOperator);

2,715,779✔

5065

      (*ppRes) = NULL;

2,716,246✔

5066

      return code;

2,716,246✔

5068

    pInfo->tableStartIndex = 0;

22,875,194✔

5069

    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

22,924,146✔

5070

    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

22,890,412✔

5071

    pInfo->groupId = tmp->groupId;

22,890,412✔

5072

    startGroupTableMergeScan(pOperator);

22,923,638✔

5075

  SSDataBlock* pBlock = NULL;

56,027,732✔

5076

  while (pInfo->tableStartIndex < tableListSize) {

65,147,329✔

5077

    if (isTaskKilled(pTaskInfo)) {

65,167,675✔

5078

      goto _end;

73✔

5081

    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,

65,157,935✔

5083

    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {

65,166,586✔

5084

      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

1,785,522✔

5085

      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);

1,785,522✔

5086

      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);

1,785,522✔

5088

    if (pBlock != NULL) {

65,161,336✔

5089

      pBlock->info.id.groupId = pInfo->groupId;

33,106,099✔

5090

      pOperator->resultInfo.totalRows += pBlock->info.rows;

33,105,567✔

5091

      pInfo->bGroupProcessed = true;

33,105,567✔

5092

      break;

33,106,082✔

5094

      if (pInfo->bNewFilesetEvent) {

32,055,237✔

5095

        stopDurationForGroupTableMergeScan(pOperator);

3,039,949✔

5096

        code = startDurationForGroupTableMergeScan(pOperator);

3,039,949✔

5097

        QUERY_CHECK_CODE(code, lino, _end);

3,039,208✔

5100

        stopGroupTableMergeScan(pOperator);

29,017,108✔

5101

        if (pInfo->tableEndIndex >= tableListSize - 1) {

29,010,723✔

5102

          setOperatorCompleted(pOperator);

22,927,004✔

5103

          break;

22,934,691✔

5106

        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;

6,078,016✔

5107

        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);

6,078,016✔

5108

        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);

6,078,016✔

5109

        pInfo->groupId = tmp->groupId;

6,078,016✔

5110

        startGroupTableMergeScan(pOperator);

6,078,016✔

5111

        resetLimitInfoForNextGroup(&pInfo->limitInfo);

6,078,016✔

5116

  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;

56,042,585✔

5118

_end:

56,035,037✔

5119

  if (code != TSDB_CODE_SUCCESS) {

56,034,570✔

5124

    (*ppRes) = pBlock;

56,034,570✔

5127

  return code;

56,031,603✔

5136

void destroyTableMergeScanOperatorInfo(void* param) {

25,250,460✔

5137

  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;

25,250,460✔

5140

  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {

25,250,460✔

5141

    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);

25,251,894✔

5142

    pTableScanInfo->base.dataReader = NULL;

25,230,783✔

5145

  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {

25,233,878✔

5152

  tsortDestroySortHandle(pTableScanInfo->pSortHandle);

25,240,644✔

5153

  pTableScanInfo->pSortHandle = NULL;

25,235,888✔

5154

  taosHashCleanup(pTableScanInfo->mSkipTables);

25,244,653✔

5155

  pTableScanInfo->mSkipTables = NULL;

25,230,305✔

5156

  blockDataDestroy(pTableScanInfo->pSortInputBlock);

25,233,407✔

5157

  pTableScanInfo->pSortInputBlock = NULL;

25,246,573✔

5160

  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);

25,248,390✔

5162

  blockDataDestroy(pTableScanInfo->pResBlock);

25,247,443✔

5163

  pTableScanInfo->pResBlock = NULL;

25,252,873✔

5166

  blockDataDestroy(pTableScanInfo->pReaderBlock);

25,253,839✔

5167

  pTableScanInfo->pReaderBlock = NULL;

25,249,367✔

5168

  taosArrayDestroy(pTableScanInfo->pSortInfo);

25,254,954✔

5170

  stopSubTablesTableMergeScan(pTableScanInfo);

25,249,174✔

5172

  taosMemoryFreeClear(param);

25,237,348✔

5173

25,237,985✔

5175

int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {

2,817,798✔

5176

  if (pOptr == NULL) {

2,817,798✔

5181

  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));

2,817,798✔

5182

  if (!execInfo) {

2,819,427✔

5185

  STableMergeScanInfo* pInfo = pOptr->info;

2,819,427✔

5186

  execInfo->blockRecorder = pInfo->base.readRecorder;

2,819,427✔

5187

  execInfo->sortExecInfo = pInfo->sortExecInfo;

2,819,427✔

5189

  *pOptrExplain = execInfo;

2,819,427✔

5190

  *len = sizeof(STableMergeScanExecInfo);

2,819,065✔

5192

  return TSDB_CODE_SUCCESS;

2,819,427✔

5195

static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {

2,287,692✔

5196

  int32_t         code = TSDB_CODE_SUCCESS;

2,287,692✔

5197

  STableMergeScanInfo*   pInfo = pOper->info;

2,287,692✔

5198

  pOper->status = OP_NOT_OPENED;

2,287,692✔

5200

  pInfo->tableEndIndex = 0;

2,287,692✔

5201

  pInfo->tableStartIndex = 0;

2,287,692✔

5202

  pInfo->hasGroupId = false;

2,287,692✔

5203

  if (pInfo->base.readerAPI.tsdReaderClose) {

2,287,692✔

5204

    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);

2,287,692✔

5206

  pInfo->base.dataReader = NULL;

2,287,692✔

5207

  pInfo->base.scanFlag = MAIN_SCAN;

2,287,692✔

5209

  pInfo->base.limitInfo = (SLimitInfo){0};

2,287,692✔

5210

  pInfo->base.limitInfo.limit.limit = -1;

2,287,692✔

5211

  pInfo->base.limitInfo.slimit.limit = -1;

2,287,692✔

5213

  tableListDestroy(pInfo->base.pTableListInfo);

2,287,692✔

5214

  pInfo->base.pTableListInfo = tableListCreate();

2,287,447✔

5215

  if (!pInfo->base.pTableListInfo) {

2,287,692✔

5219

  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;

2,287,692✔

5221

  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;

2,287,692✔

5222

  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,

4,575,384✔

5224

                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);

4,575,384✔

5225

  if (code) {

2,287,692✔

5230

  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);

2,287,692✔

5231

  cleanupQueryTableDataCond(&pInfo->base.cond);

2,287,443✔

5232

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);

2,287,692✔

5233

  if (code) {

2,287,692✔

5238

  tsortDestroySortHandle(pInfo->pSortHandle);

2,287,692✔

5239

  pInfo->pSortHandle = NULL;

2,287,692✔

5241

  taosHashCleanup(pInfo->mSkipTables);

2,287,692✔

5242

  pInfo->mSkipTables = NULL;

2,287,692✔

5243

  pOper->resultInfo.totalRows = 0;

2,287,692✔

5245

  pInfo->bGroupProcessed = false;

2,287,448✔

5246

  pInfo->bNewFilesetEvent = false;

2,287,692✔

5247

  pInfo->bNextDurationBlockEvent = false;

2,287,692✔

5248

  pInfo->rtnNextDurationBlocks = false;

2,287,692✔

5249

  pInfo->nextDurationBlocksIdx = 0;

2,287,692✔

5250

  pInfo->bSortRowId = false;

2,287,692✔

5252

  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {

2,287,692✔

5258

  pInfo->numNextDurationBlocks = 0;

2,287,692✔

5260

  stopSubTablesTableMergeScan(pInfo);

2,287,448✔

5261

  return code;

2,287,692✔

5264

int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,

25,171,950✔

5267

  QRY_PARAM_CHECK(pOptrInfo);

25,171,950✔

5269

  int32_t              code = TSDB_CODE_SUCCESS;

25,188,851✔

5270

  int32_t              lino = 0;

25,188,851✔

5271

  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));

25,188,851✔

5272

  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

25,123,126✔

5273

  if (pInfo == NULL || pOperator == NULL) {

25,061,557✔

5278

  pOperator->pPhyNode = pTableScanNode;

25,063,517✔

5279

  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;

25,097,091✔

5281

  int32_t numOfCols = 0;

25,104,927✔

5282

  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,

25,122,334✔

5284

  QUERY_CHECK_CODE(code, lino, _error);

25,187,878✔

5286

  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);

25,187,878✔

5287

  QUERY_CHECK_CODE(code, lino, _error);

25,088,409✔

5289

  if (pTableScanNode->scan.pScanPseudoCols != NULL) {

25,088,409✔

5290

    SExprSupp* pSup = &pInfo->base.pseudoSup;

9,546,284✔

5291

    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);

9,516,383✔

5292

    QUERY_CHECK_CODE(code, lino, _error);

9,540,903✔

5294

    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,

9,540,903✔

5296

    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);

9,494,859✔

5299

  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};

25,064,157✔

5301

  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {

24,979,349✔

5306

  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;

24,979,349✔

5307

  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;

25,100,194✔

5308

  pInfo->base.scanFlag = MAIN_SCAN;

24,962,233✔

5309

  pInfo->base.readHandle = *readHandle;

25,022,046✔

5311

  pInfo->readIdx = -1;

25,149,671✔

5313

  pInfo->base.limitInfo.limit.limit = -1;

24,977,852✔

5314

  pInfo->base.limitInfo.slimit.limit = -1;

25,020,465✔

5315

  pInfo->base.pTableListInfo = pTableListInfo;

25,066,133✔

5317

  pInfo->sample.sampleRatio = pTableScanNode->ratio;

25,155,625✔

5318

  pInfo->sample.seed = taosGetTimestampSec();

25,047,287✔

5320

  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,

25,126,008✔

5321

                            pTaskInfo->pStreamRuntimeInfo);

25,126,449✔

5322

  QUERY_CHECK_CODE(code, lino, _error);

25,038,372✔

5324

  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);

25,038,372✔

5326

  pInfo->mergeLimit = -1;

25,046,630✔

5327

  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;

25,140,516✔

5328

  if (hasLimit) {

25,038,376✔

5329

    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1

3,419,084✔

5330

                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset

528,746✔

5331

                            : pInfo->limitInfo.limit.limit;

2,231,409✔

5332

    pInfo->mSkipTables = NULL;

1,704,576✔

5335

  initResultSizeInfo(&pOperator->resultInfo, 1024);

25,027,767✔

5336

  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);

25,101,972✔

5337

  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);

25,230,549✔

5338

  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);

25,112,240✔

5339

  QUERY_CHECK_CODE(code, lino, _error);

25,217,800✔

5340

  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {

25,217,800✔

5341

    pInfo->bSortRowId = true;

4,690,311✔

5343

    pInfo->bSortRowId = false;

20,494,619✔

5346

  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);

25,165,212✔

5347

  QUERY_CHECK_CODE(code, lino, _error);

25,157,211✔

5349

  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);

25,157,211✔

5350

  QUERY_CHECK_CODE(code, lino, _error);

25,154,170✔

5352

  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);

25,154,170✔

5353

  QUERY_CHECK_CODE(code, lino, _error);

25,167,524✔

5355

  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;

25,167,524✔

5357

  int32_t  rowSize = pInfo->pResBlock->info.rowSize;

25,191,158✔

5358

  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);

25,178,577✔

5360

  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);

25,072,881✔

5363

  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);

25,185,256✔

5364

  QUERY_CHECK_CODE(code, lino, _error);

25,205,386✔

5366

  if (!tsExperimental) {

25,205,386✔

5369

    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;

25,205,386✔

5372

  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,

25,189,042✔

5374

  pOperator->exprSupp.numOfExprs = numOfCols;

25,129,702✔

5376

  pOperator->fpSet = createOperatorFpSet(

25,132,645✔

5377

      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,

25,196,191✔

5380

  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);

25,116,780✔

5381

  pOperator->cost.openCost = 0;

25,173,756✔

5383

  *pOptrInfo = pOperator;

25,185,817✔

5384

  return code;

25,042,415✔

5423

int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {

24,455✔

5424

  if (scanCols != NULL) {

24,455✔

5425

    SNode* pNode = NULL;

14,017✔

5426

    FOREACH(pNode, scanCols) {

32,721✔

5427

      if (nodeType(pNode) != QUERY_NODE_TARGET) {

18,704✔

5430

      STargetNode* targetNode = (STargetNode*)pNode;

18,704✔

5431

      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {

18,704✔

5434

      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);

18,704✔

5435

      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {

18,704✔

5436

        supp->dbNameSlotId = targetNode->slotId;

9,214✔

5437

      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {

9,490✔

5438

        supp->stbNameSlotId = targetNode->slotId;

9,490✔

5442

  return TSDB_CODE_SUCCESS;

24,455✔

5445

int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {

24,455✔

5446

  if (pseudoCols != NULL) {

24,455✔

5447

    SNode* pNode = NULL;

24,455✔

5448

    FOREACH(pNode, pseudoCols) {

48,910✔

5449

      if (nodeType(pNode) != QUERY_NODE_TARGET) {

24,455✔

5452

      STargetNode* targetNode = (STargetNode*)pNode;

24,455✔

5453

      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {

24,455✔

5456

      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);

24,455✔

5457

      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {

24,455✔

5458

        supp->tbCountSlotId = targetNode->slotId;

24,455✔

5462

  return TSDB_CODE_SUCCESS;

24,455✔

5465

int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {

24,455✔

5466

  if (groupTags != NULL) {

24,455✔

5467

    SNode* pNode = NULL;

14,017✔

5468

    FOREACH(pNode, groupTags) {

32,721✔

5469

      if (nodeType(pNode) != QUERY_NODE_COLUMN) {

18,704✔

5472

      SColumnNode* colNode = (SColumnNode*)pNode;

18,704✔

5473

      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {

18,704✔

5474

        supp->groupByDbName = true;

9,214✔

5476

      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {

18,704✔

5477

        supp->groupByStbName = true;

9,490✔

5481

    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);

10,438✔

5482

    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);

10,438✔

5484

  return TSDB_CODE_SUCCESS;

24,455✔

5487

int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,

24,455✔

5489

  int32_t code = 0;

24,455✔

5490

  code = tblCountScanGetInputs(groupTags, tableName, supp);

24,455✔

5491

  if (code != TSDB_CODE_SUCCESS) {

24,455✔

5496

  supp->dbNameSlotId = -1;

24,455✔

5497

  supp->stbNameSlotId = -1;

24,455✔

5498

  supp->tbCountSlotId = -1;

24,455✔

5500

  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);

24,455✔

5501

  if (code != TSDB_CODE_SUCCESS) {

24,455✔

5506

  code = tblCountScanGetCountSlotId(pseudoCols, supp);

24,455✔

5507

  if (code != TSDB_CODE_SUCCESS) {

24,455✔

5511

  return code;

24,455✔

5514

int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,

24,251✔

5516

  QRY_PARAM_CHECK(pOptrInfo);

24,251✔

5518

  int32_t                      code = TSDB_CODE_SUCCESS;

24,455✔

5519

  int32_t                      lino = 0;

24,455✔

5520

  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;

24,455✔

5521

  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));

24,455✔

5522

  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

24,455✔

5523

  if (!pInfo || !pOperator) {

24,455✔

5528

  pInfo->readHandle = *readHandle;

24,455✔

5530

  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;

24,455✔

5531

  initResultSizeInfo(&pOperator->resultInfo, 1);

24,455✔

5532

  pInfo->pRes = createDataBlockFromDescNode(pDescNode);

24,455✔

5533

  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

24,455✔

5535

  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);

24,455✔

5536

  QUERY_CHECK_CODE(code, lino, _error);

24,455✔

5538

  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,

24,455✔

5541

  QUERY_CHECK_CODE(code, lino, _error);

24,455✔

5543

  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,

24,455✔

5545

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,

24,417✔

5547

  *pOptrInfo = pOperator;

24,274✔

5548

  return code;

24,417✔

5562

int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,

33,873✔

5564

  int32_t code = TSDB_CODE_SUCCESS;

33,873✔

5565

  int32_t lino = 0;

33,873✔

5566

  if (pSupp->dbNameSlotId != -1) {

33,873✔

5567

    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);

13,896✔

5568

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);

13,896✔

5569

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

13,896✔

5571

    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};

13,896✔

5572

    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);

13,896✔

5574

    varDataSetLen(varDbName, strlen(dbName));

13,896✔

5575

    code = colDataSetVal(colInfoData, 0, varDbName, false);

13,761✔

5576

    QUERY_CHECK_CODE(code, lino, _end);

13,896✔

5579

  if (pSupp->stbNameSlotId != -1) {

34,039✔

5580

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);

18,149✔

5581

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

18,149✔

5582

    if (strlen(stbName) != 0) {

18,149✔

5583

      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};

13,018✔

5584

      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);

13,018✔

5585

      varDataSetLen(varStbName, strlen(stbName));

13,018✔

5586

      code = colDataSetVal(colInfoData, 0, varStbName, false);

13,018✔

5587

      QUERY_CHECK_CODE(code, lino, _end);

13,018✔

5593

  if (pSupp->tbCountSlotId != -1) {

34,039✔

5594

    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);

33,873✔

5595

    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);

34,039✔

5596

    code = colDataSetVal(colInfoData, 0, (char*)&count, false);

34,039✔

5597

    QUERY_CHECK_CODE(code, lino, _end);

34,039✔

5599

  pRes->info.rows = 1;

34,039✔

5601

_end:

34,039✔

5602

  if (code != TSDB_CODE_SUCCESS) {

34,039✔

5605

  return code;

33,873✔

5608

static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {

10,364✔

5609

  STableCountScanSupp* pSupp = &pInfo->supp;

10,364✔

5610

  SSDataBlock*         pRes = pInfo->pRes;

10,364✔

5612

  size_t infodbTableNum;

10,364✔

5613

  getInfosDbMeta(NULL, &infodbTableNum);

10,364✔

5614

  infodbTableNum -= 1;

10,364✔

5615

  size_t perfdbTableNum;

10,364✔

5616

  getPerfDbMeta(NULL, &perfdbTableNum);

10,364✔

5618

  if (pSupp->groupByDbName || pSupp->groupByStbName) {

10,364✔

5619

    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);

8,880✔

5620

    return (pRes->info.rows > 0) ? pRes : NULL;

8,880✔

5622

    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);

1,484✔

5623

    return (pRes->info.rows > 0) ? pRes : NULL;

1,484✔

5627

static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,

1,484✔

5629

  int32_t        code = TSDB_CODE_SUCCESS;

1,484✔

5630

  int32_t        lino = 0;

1,484✔

5631

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

1,484✔

5632

  if (strlen(pSupp->stbNameFilter) != 0) {

1,484✔

5634

    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);

507✔

5635

    QUERY_CHECK_CODE(code, lino, _end);

507✔

5636

  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {

977✔

5637

    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);

169✔

5638

    QUERY_CHECK_CODE(code, lino, _end);

169✔

5639

  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {

808✔

5642

  } else if (strlen(pSupp->dbNameFilter) == 0) {

808✔

5643

    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);

639✔

5644

    QUERY_CHECK_CODE(code, lino, _end);

639✔

5647

    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);

169✔

5648

    QUERY_CHECK_CODE(code, lino, _end);

169✔

5651

_end:

169✔

5652

  if (code != TSDB_CODE_SUCCESS) {

1,484✔

5657

  setOperatorCompleted(pOperator);

1,484✔

5658

1,484✔

5660

static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

8,880✔

5663

  int32_t        code = TSDB_CODE_SUCCESS;

8,880✔

5664

  int32_t        lino = 0;

8,880✔

5665

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

8,880✔

5666

  if (pInfo->currGrpIdx == 0) {

8,880✔

5667

    uint64_t groupId = 0;

2,960✔

5668

    if (pSupp->groupByDbName) {

2,960✔

5669

      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));

2,016✔

5671

      groupId = calcGroupId("", 0);

944✔

5674

    pRes->info.id.groupId = groupId;

2,960✔

5675

    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);

2,960✔

5676

    QUERY_CHECK_CODE(code, lino, _end);

2,960✔

5677

  } else if (pInfo->currGrpIdx == 1) {

5,920✔

5678

    uint64_t groupId = 0;

2,960✔

5679

    if (pSupp->groupByDbName) {

2,960✔

5680

      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));

2,016✔

5682

      groupId = calcGroupId("", 0);

944✔

5685

    pRes->info.id.groupId = groupId;

2,960✔

5686

    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);

2,960✔

5687

    QUERY_CHECK_CODE(code, lino, _end);

2,960✔

5689

    setOperatorCompleted(pOperator);

2,960✔

5691

  pInfo->currGrpIdx++;

8,880✔

5693

_end:

8,880✔

5694

  if (code != TSDB_CODE_SUCCESS) {

8,880✔

5699

8,880✔

5701

static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {

58,494✔

5702

  int32_t                      code = TSDB_CODE_SUCCESS;

58,494✔

5703

  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;

58,494✔

5704

  STableCountScanOperatorInfo* pInfo = pOperator->info;

58,359✔

5705

  STableCountScanSupp*         pSupp = &pInfo->supp;

58,359✔

5706

  SSDataBlock*                 pRes = pInfo->pRes;

58,359✔

5708

  blockDataCleanup(pRes);

58,359✔

5709

  QRY_PARAM_CHECK(ppRes);

58,328✔

5711

  if (pOperator->status == OP_EXEC_DONE) {

58,494✔

5712

    return code;

14,040✔

5715

  if (pInfo->readHandle.mnd != NULL) {

44,454✔

5716

    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);

10,364✔

5717

    return code;

10,364✔

5720

  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);

34,090✔

5721

  if (code != TSDB_CODE_SUCCESS) {

33,924✔

5726

  if (pRes->info.rows > 0) {

33,924✔

5727

    *ppRes = pRes;

26,635✔

5730

  return code;

34,090✔

5733

static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

34,090✔

5735

  int32_t        code = TSDB_CODE_SUCCESS;

34,090✔

5736

  int32_t        lino = 0;

34,090✔

5737

  const char*    db = NULL;

34,090✔

5738

  int32_t        vgId = 0;

34,090✔

5739

  char           dbName[TSDB_DB_NAME_LEN] = {0};

34,090✔

5740

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

34,090✔

5741

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

34,090✔

5744

  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);

34,090✔

5745

  SName sn = {0};

34,090✔

5747

  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);

34,090✔

5748

  QUERY_CHECK_CODE(code, lino, _end);

34,090✔

5750

  code = tNameGetDbName(&sn, dbName);

34,090✔

5751

  QUERY_CHECK_CODE(code, lino, _end);

34,090✔

5753

  if (pSupp->groupByDbName || pSupp->groupByStbName) {

34,090✔

5754

    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);

25,136✔

5756

    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);

8,954✔

5759

_end:

33,921✔

5760

  if (code != TSDB_CODE_SUCCESS) {

34,090✔

5765

  return code;

34,090✔

5768

static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

25,136✔

5770

  int32_t        code = TSDB_CODE_SUCCESS;

25,136✔

5771

  int32_t        lino = 0;

25,136✔

5772

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

25,136✔

5773

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

25,136✔

5775

  if (pSupp->groupByStbName) {

25,136✔

5776

    if (pInfo->stbUidList == NULL) {

21,534✔

5777

      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));

7,455✔

5778

      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);

7,455✔

5779

      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);

7,455✔

5780

      QUERY_CHECK_CODE(code, lino, _end);

7,455✔

5783

    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {

21,534✔

5784

      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);

13,018✔

5785

      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);

13,018✔

5786

      QUERY_CHECK_CODE(code, lino, _end);

13,018✔

5788

      pInfo->currGrpIdx++;

13,018✔

5789

    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {

8,516✔

5790

      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);

7,455✔

5791

      QUERY_CHECK_CODE(code, lino, _end);

7,455✔

5793

      pInfo->currGrpIdx++;

7,455✔

5795

      setOperatorCompleted(pOperator);

1,061✔

5798

    uint64_t groupId = calcGroupId(dbName, strlen(dbName));

3,602✔

5799

    pRes->info.id.groupId = groupId;

3,467✔

5801

    int64_t dbTableCount = 0;

3,602✔

5802

    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);

3,602✔

5803

    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);

3,602✔

5804

    QUERY_CHECK_CODE(code, lino, _end);

3,602✔

5805

    setOperatorCompleted(pOperator);

3,602✔

5808

_end:

25,136✔

5809

  if (code != TSDB_CODE_SUCCESS) {

25,136✔

5813

  return code;

25,136✔

5816

static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,

8,954✔

5818

  int32_t        code = TSDB_CODE_SUCCESS;

8,954✔

5819

  int32_t        lino = 0;

8,954✔

5820

  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;

8,954✔

5821

  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

8,954✔

5823

  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {

8,954✔

5827

  } else if (strlen(pSupp->stbNameFilter) != 0) {

8,954✔

5828

    uint64_t uid = 0;

2,968✔

5829

    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);

2,968✔

5830

    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {

2,802✔

5832

      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);

1,352✔

5833

      QUERY_CHECK_CODE(code, lino, _end);

1,186✔

5835

      QUERY_CHECK_CODE(code, lino, _end);

1,450✔

5837

      int64_t numOfChildTables = 0;

1,450✔

5838

      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);

1,450✔

5839

      QUERY_CHECK_CODE(code, lino, _end);

1,450✔

5841

      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);

1,450✔

5842

      QUERY_CHECK_CODE(code, lino, _end);

1,450✔

5845

    int64_t tbNumVnode = 0;

5,986✔

5846

    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);

5,986✔

5847

    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);

5,986✔

5848

    QUERY_CHECK_CODE(code, lino, _end);

5,986✔

5851

_end:

8,788✔

5852

  if (code != TSDB_CODE_SUCCESS) {

8,788✔

5857

  setOperatorCompleted(pOperator);

8,788✔

5858

  return code;

8,619✔

5861

static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,

7,455✔

5863

  int32_t code = TSDB_CODE_SUCCESS;

7,455✔

5864

  int32_t lino = 0;

7,455✔

5865

  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};

7,455✔

5866

  if (pSupp->groupByDbName) {

7,455✔

5867

    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");

3,596✔

5870

  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));

7,455✔

5871

  pRes->info.id.groupId = groupId;

7,455✔

5873

  int64_t numOfTables = 0;

7,455✔

5874

  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);

7,455✔

5876

  if (numOfTables != 0) {

7,455✔

5877

    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);

1,061✔

5880

_end:

6,394✔

5881

  if (code != TSDB_CODE_SUCCESS) {

7,455✔

5884

  return code;

7,455✔

5887

static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,

13,018✔

5889

  int32_t code = TSDB_CODE_SUCCESS;

13,018✔

5890

  int32_t lino = 0;

13,018✔

5891

  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};

13,018✔

5892

  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);

13,018✔

5893

  QUERY_CHECK_CODE(code, lino, _end);

13,018✔

5895

  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};

13,018✔

5896

  if (pSupp->groupByDbName) {

13,018✔

5897

    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));

5,976✔

5899

    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));

7,042✔

5902

  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));

13,018✔

5903

  pRes->info.id.groupId = groupId;

13,018✔

5905

  int64_t ctbNum = 0;

13,018✔

5906

  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);

13,018✔

5907

  QUERY_CHECK_CODE(code, lino, _end);

13,018✔

5908

  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);

13,018✔

5909

  QUERY_CHECK_CODE(code, lino, _end);

13,018✔

5911

_end:

13,018✔

5912

  if (code != TSDB_CODE_SUCCESS) {

13,018✔

5915

  return code;

13,018✔

5918

static void destoryTableCountScanOperator(void* param) {

24,455✔

5919

  STableCountScanOperatorInfo* pTableCountScanInfo = param;

24,455✔

5920

  blockDataDestroy(pTableCountScanInfo->pRes);

24,455✔

5922

  taosArrayDestroy(pTableCountScanInfo->stbUidList);

24,455✔

5923

  taosMemoryFreeClear(param);

24,455✔

5924

24,455✔

taosdata / TDengine / #4938

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

taosdata / TDengine / #4938

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