taosdata / TDengine / #4927

coverage: 66.12% (+0.07%) from 66.053%
#4927

push

travis-ci

web-flow 
fix memleak decimal (#34283)

2 of 16 new or added lines in 1 file covered. (12.5%)

476 existing lines in 124 files now uncovered.

200574 of 303348 relevant lines covered (66.12%)

130242324.59 hits per line

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

83.62
/source/libs/executor/src/scanoperator.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#include "executor.h"










17



#include "executorInt.h"










18



#include "filter.h"










19



#include "function.h"










20



#include "functionMgt.h"










21



#include "os.h"










22



#include "querynodes.h"










23



#include "streamexecutorInt.h"










24



#include "systable.h"










25



#include "tname.h"










26












27



#include "tdatablock.h"










28



#include "tmsg.h"










29



#include "ttime.h"










30












31



#include "operator.h"










32



#include "query.h"










33



#include "querytask.h"










34



#include "tcompare.h"










35



#include "thash.h"










36



#include "ttypes.h"










37












38



#include "function.h"










39



#include "storageapi.h"










40



#include "wal.h"










41












42



int32_t scanDebug = 0;










43












44



#define MULTI_READER_MAX_TABLE_NUM     5000










45



#define SET_REVERSE_SCAN_FLAG(_info)   ((_info)->scanFlag = REVERSE_SCAN)










46



#define SWITCH_ORDER(n)                (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))










47



#define STREAM_SCAN_OP_NAME            "StreamScanOperator"










48



#define STREAM_SCAN_OP_STATE_NAME      "StreamScanFillHistoryState"










49



#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint"










50












51



typedef struct STableMergeScanExecInfo {










52



  SFileBlockLoadRecorder blockRecorder;










53



  SSortExecInfo          sortExecInfo;










54



} STableMergeScanExecInfo;










55












56



typedef struct STableMergeScanSortSourceParam {










57



  SOperatorInfo* pOperator;










58



  int32_t        readerIdx;










59



  uint64_t       uid;










60



  STsdbReader*   reader;










61



} STableMergeScanSortSourceParam;










62












63



typedef struct STableCountScanOperatorInfo {










64



  SReadHandle  readHandle;










65



  SSDataBlock* pRes;










66












67



  STableCountScanSupp supp;










68












69



  int32_t currGrpIdx;










70



  SArray* stbUidList;  // when group by db_name and/or stable_name










71



} STableCountScanOperatorInfo;










72












73



static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);










74



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);










75












76



bool processBlockWithProbability(const SSampleExecInfo* pInfo) {




702,932,381✔





77



#if 0










78



  if (pInfo->sampleRatio == 1) {










79



    return true;










80



  }










81












82



  uint32_t val = taosRandR((uint32_t*) &pInfo->seed);










83



  return (val % ((uint32_t)(1/pInfo->sampleRatio))) == 0;










84



#else










85



  return true;




702,932,381✔





86



#endif










87



}










88












89



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




65,728✔





90



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




65,728✔





91



    SWITCH_ORDER(pCtx[i].order);




×







92



  }










93



}




65,728✔





94












95



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




744,920,139✔





96



  int32_t     code = TSDB_CODE_SUCCESS;




744,920,139✔





97



  STimeWindow w = {0};




744,920,139✔





98












99



  // 0 by default, which means it is not a interval operator of the upstream operator.










100



  if (pInterval->interval == 0) {




745,054,524✔





101



    *overlap = false;




698,148,778✔





102



    return code;




698,224,819✔





103



  }










104












105



  if (order == TSDB_ORDER_ASC) {




46,776,261✔





106



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




44,754,417✔





107



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




44,735,428✔





108



      qError("w.ekey:%" PRId64 " < pBlockInfo->window.skey:%" PRId64, w.ekey, pBlockInfo->window.skey);




×







109



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







110



    }










111












112



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




44,716,751✔





113



      *overlap = true;




36,281,033✔





114



      return code;




36,279,905✔





115



    }










116












117



    while (1) {










118



      getNextTimeWindow(pInterval, &w, order);




8,464,236✔





119



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




8,491,955✔





120



        break;




8,225,553✔





121



      }










122












123



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




263,226✔





124



        qError("w.ekey:%" PRId64 " <= pBlockInfo->window.ekey:%" PRId64, w.ekey, pBlockInfo->window.ekey);




×







125



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







126



      }










127



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




263,226✔





128



        *overlap = true;




263,226✔





129



        return code;




263,226✔





130



      }










131



    }










132



  } else {










133



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




2,021,844✔





134



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




2,022,555✔





135



      qError("w.skey:%" PRId64 " > pBlockInfo->window.skey:%" PRId64, w.skey, pBlockInfo->window.ekey);




×







136



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







137



    }










138












139



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




2,023,352✔





140



      *overlap = true;




1,570,996✔





141



      return code;




1,570,996✔





142



    }










143












144



    while (1) {










145



      getNextTimeWindow(pInterval, &w, order);




450,848✔





146



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




452,083✔





147



        break;




450,153✔





148



      }










149












150



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




2,550✔





151



        qError("w.skey:%" PRId64 " >= pBlockInfo->window.skey:%" PRId64, w.skey, pBlockInfo->window.skey);




×







152



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







153



      }










154



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




2,550✔





155



        *overlap = true;




2,550✔





156



        return code;




2,550✔





157



      }










158



    }










159



  }










160












161



  *overlap = false;




8,675,706✔





162



  return code;




8,675,427✔





163



}










164












165



// this function is for table scanner to extract temporary results of upstream aggregate results.










166



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




168,724,811✔





167



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




168,724,811✔





168



    return NULL;




×







169



  }










170












171



  int64_t buf[2] = {0};




168,756,386✔





172



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




168,723,345✔





173












174



  STableScanInfo* pTableScanInfo = pOperator->info;




168,702,413✔





175












176



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




168,730,493✔





177



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










178












179



  if (p1 == NULL) {




168,794,559✔





180



    return NULL;




55,847,596✔





181



  }










182












183



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




112,946,963✔





184



  if (NULL == *pPage) {




112,907,333✔





185



    return NULL;




×







186



  }










187












188



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




112,914,585✔





189



}










190












191



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




12,110,072✔





192



  if (NULL == pTableScanInfo->pIgnoreTables) {




12,110,072✔





193



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




1,286,807✔





194



    pTableScanInfo->pIgnoreTables =




1,286,807✔





195



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




1,286,807✔





196



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,286,807✔





197



      return terrno;




×







198



    }










199



  }










200












201



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




12,110,072✔





202



                                sizeof(pTableScanInfo->scanTimes));










203



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




12,109,678✔





204



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));




×







205



    return tempRes;




×







206



  }










207



  return TSDB_CODE_SUCCESS;




12,109,678✔





208



}










209












210



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




811,965,820✔





211



  STableScanInfo* pTableScanInfo = pOperator->info;




811,965,820✔





212



  int32_t         code = TSDB_CODE_SUCCESS;




812,426,857✔





213












214



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




812,426,857✔





215



    return TSDB_CODE_SUCCESS;




643,357,781✔





216



  }










217












218



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




168,725,673✔





219












220



  SFilePage*  pPage = NULL;




168,731,071✔





221



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




168,697,744✔





222












223



  if (pRow == NULL) {




168,755,643✔





224



    return TSDB_CODE_SUCCESS;




55,832,438✔





225



  }










226












227



  bool notLoadBlock = true;




112,923,205✔





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✔





230












231



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




2,147,483,647✔





232












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;




100,827,240✔





236



      break;




100,827,240✔





237



    }










238



  }










239












240



  // release buffer pages










241



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




111,531,492✔





242












243



  if (notLoadBlock) {




112,917,246✔





244



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




12,110,482✔





245



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




12,110,482✔





246



  }










247












248



  return code;




112,836,662✔





249



}










250












251



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




8,965,298✔





252



                                  int32_t numOfRows, bool* keep) {










253



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




8,965,298✔





254



    *keep = true;




×







255



    return TSDB_CODE_SUCCESS;




×







256



  }










257












258



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




8,965,298✔





259



}










260












261



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




162,963,944✔





262



                              bool* pLoad) {










263



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




162,963,944✔





264



  bool         allColumnsHaveAgg = true;




163,017,061✔





265



  bool         hasNullSMA = false;




163,037,665✔





266



  if (pLoad != NULL) {




162,990,462✔





267



    *pLoad = false;




163,059,072✔





268



  }










269












270



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




162,945,850✔





271



                                                               &hasNullSMA);










272



  if (code != TSDB_CODE_SUCCESS) {




162,969,935✔





273



    return code;




×







274



  }










275












276



  if (!allColumnsHaveAgg || hasNullSMA) {




162,969,935✔





277



    *pLoad = false;




148,538,215✔





278



  } else {










279



    *pLoad = true;




14,431,720✔





280



  }










281












282



  return code;




162,913,241✔





283



}










284












285



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




849,444,535✔





286



                                  int32_t rows) {










287



  int32_t    code = 0;




849,444,535✔





288



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




849,444,535✔





289



  if (pSup->numOfExprs > 0) {




849,886,978✔





290



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




329,187,743✔





291



                                  pTaskInfo, &pTableScanInfo->metaCache);










292



    // ignore the table not exists error, since this table may have been dropped during the scan procedure.










293



    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




329,034,843✔





294



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




×







295



      code = 0;




×







296



    }










297



  }










298












299



  return code;




849,535,258✔





300



}










301












302



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




1,423,335,137✔





303



  SLimit*     pLimit = &pLimitInfo->limit;




1,423,335,137✔





304



  const char* id = GET_TASKID(pTaskInfo);




1,423,550,817✔





305












306



  if (pLimitInfo->remainOffset > 0) {




1,423,744,978✔





307



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




5,381,430✔





308



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




2,626,118✔





309



      blockDataEmpty(pBlock);




2,626,118✔





310



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




2,626,118✔





311



      return false;




2,626,118✔





312



    } else {










313



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




2,755,312✔





314



      if (code != TSDB_CODE_SUCCESS) {




2,755,312✔





315



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




×







316



        pTaskInfo->code = code;




×







317



        T_LONG_JMP(pTaskInfo->env, code);




×







318



      }










319



      pLimitInfo->remainOffset = 0;




2,755,312✔





320



    }










321



  }










322












323



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




1,421,142,019✔





324



    // limit the output rows










325



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




40,177,456✔





326



    blockDataKeepFirstNRows(pBlock, keep);




40,173,192✔





327












328



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




40,173,899✔





329



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




40,177,298✔





330



    return true;




40,175,067✔





331



  }










332












333



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




1,380,612,904✔





334



  return false;




1,380,861,983✔





335



}










336












337



static bool isDynVtbScan(SOperatorInfo* pOperator) {




×







338



  return pOperator->dynamicTask && ((STableScanInfo*)(pOperator->info))->virtualStableScan;




×







339



}










340












341



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




848,828,701✔





342



                             uint32_t* status) {










343



  int32_t        code = TSDB_CODE_SUCCESS;




848,828,701✔





344



  int32_t        lino = 0;




848,828,701✔





345



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




848,828,701✔





346



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




849,103,790✔





347



  bool           loadSMA = false;




848,978,413✔





348












349



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




848,978,413✔





350












351



  pCost->totalBlocks += 1;




848,916,537✔





352



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




848,933,627✔





353



  *status = pTableScanInfo->dataBlockLoadFlag;




848,601,706✔





354












355



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




849,048,322✔





356



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




103,809,369✔





357



  } else {










358



    bool overlap = false;




745,026,491✔





359



    int  ret =










360



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




745,000,315✔





361



    if (ret != TSDB_CODE_SUCCESS) {




744,817,991✔





362



      return ret;




×







363



    }










364



    if (overlap) {




744,817,991✔





365



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




38,106,761✔





366



    }










367



  }










368












369



  SDataBlockInfo* pBlockInfo = &pBlock->info;




848,988,502✔





370



  taosMemoryFreeClear(pBlock->pBlockAgg);




848,908,564✔





371












372



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




848,789,161✔





373



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




×







374



           pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);










375



    pCost->filterOutBlocks += 1;




×







376



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




×







377



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




×







378



    return TSDB_CODE_SUCCESS;




×







379



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




848,533,400✔





380



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




27,701,706✔





381



           GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows,










382



           pBlockInfo->id.uid);










383



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




27,706,380✔





384



    pCost->skipBlocks += 1;




27,714,883✔





385



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




27,719,101✔





386



    return code;




27,706,378✔





387



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




820,784,398✔





388



    pCost->loadBlockStatis += 1;




59,188,732✔





389



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




59,206,386✔





390



    bool success = true;




59,206,386✔





391



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




59,203,374✔





392



    if (code) {




59,155,841✔





393



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




×







394



      qError("%s failed to retrieve sma info", GET_TASKID(pTaskInfo));




×







395



      QUERY_CHECK_CODE(code, lino, _end);




23,098✔





396



    }










397












398



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




59,178,939✔





399



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




5,466,422✔





400



             pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);










401



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




5,466,422✔





402



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




5,466,422✔





403



      return code;




5,466,422✔





404



    } else {










405



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




53,712,517✔





406



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




53,736,207✔





407



    }










408



  }










409












410



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




815,325,087✔





411



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




×







412



    qError("%s loadDataBlock invalid status:%d", GET_TASKID(pTaskInfo), *status);




×







413



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







414



  }










415












416



  // try to filter data block according to sma info










417



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




815,336,500✔





418



    bool success = true;




103,811,052✔





419



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




103,804,703✔





420



    if (code) {




103,708,040✔





421



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




×







422



      qError("%s failed to retrieve sma info", GET_TASKID(pTaskInfo));




×







423



      QUERY_CHECK_CODE(code, lino, _end);




54,626✔





424



    }










425












426



    if (success) {




103,762,666✔





427



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




8,965,298✔





428



      bool   keep = false;




8,965,298✔





429



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




8,965,298✔





430



      if (code) {




8,965,298✔





431



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




×







432



        qError("%s failed to do filter by block sma, code:%s", GET_TASKID(pTaskInfo), tstrerror(code));




×







433



        QUERY_CHECK_CODE(code, lino, _end);




×







434



      }










435












436



      if (!keep) {




8,965,298✔





437



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




3,332,343✔





438



               GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);










439



        pCost->filterOutBlocks += 1;




3,332,343✔





440



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,332,343✔





441



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,332,343✔





442












443



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




3,332,343✔





444



        return TSDB_CODE_SUCCESS;




3,332,343✔





445



      }










446



    }










447



  }










448












449



  // free the sma info, since it should not be involved in *later computing process.










450



  taosMemoryFreeClear(pBlock->pBlockAgg);




812,258,855✔





451












452



  // try to filter data block according to current results










453



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




812,004,570✔





454



  if (code) {




812,009,909✔





455



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




×







456



    QUERY_CHECK_CODE(code, lino, _end);




×







457



  }










458












459



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




812,009,909✔





460



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




12,110,482✔





461



           GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);










462



    pCost->skipBlocks += 1;




12,110,876✔





463



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




12,110,876✔





464












465



    STableScanInfo* p1 = pOperator->info;




12,110,876✔





466



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




12,110,876✔





467



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




2,896,280✔





468



    } else {










469



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,214,596✔





470



    }










471



    return TSDB_CODE_SUCCESS;




12,110,876✔





472



  }










473












474



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




799,823,952✔





475



  pCost->loadBlocks += 1;




799,859,994✔





476












477



  SSDataBlock* p = NULL;




800,013,777✔





478



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




800,174,834✔





479



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




800,252,753✔





480



    return code;




×







481



  }










482












483



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




800,252,753✔





484



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




656,023,673✔





485



    // do nothing










486



  } else {










487



    // dyn vtb scan do not read tag from origin tables.










488



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




771,618,078✔





489



    if (code) {




771,377,314✔





490



      return code;




×







491



    }










492



  }










493












494



  // restore the previous value










495



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




800,040,759✔





496












497



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




800,245,018✔





498



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




100,446,462✔





499



    QUERY_CHECK_CODE(code, lino, _end);




100,450,176✔





500












501



    int64_t st = taosGetTimestampUs();




97,377,632✔





502



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




97,373,777✔





503



    pTableScanInfo->readRecorder.filterTime += el;




97,373,777✔





504












505



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




97,370,438✔





506



      pCost->filterOutBlocks += 1;




20,863,503✔





507



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




20,879,381✔





508



             GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, el);










509



    } else {










510



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




76,476,654✔





511



    }










512



  }










513












514



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




797,005,628✔





515



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




796,993,735✔





516



    setOperatorCompleted(pOperator);




3,907,707✔





517



  }










518












519



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




796,993,735✔





520












521



_end:




800,378,527✔





522



  if (code != TSDB_CODE_SUCCESS) {




800,339,321✔





523



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




3,093,444✔





524



  }










525



  return code;




800,024,651✔





526



}










527












528



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




65,728✔





529



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




65,728✔





530












531



  switchCtxOrder(pCtx, numOfOutput);




65,728✔





532



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




65,728✔





533



  // STimeWindow* pTWindow = &pTableScanInfo->cond.twindows;










534



  // TSWAP(pTWindow->skey, pTWindow->ekey);










535



}




65,728✔





536












537



typedef struct STableCachedVal {










538



  const char* pName;










539



  STag*       pTags;










540



} STableCachedVal;










541












542



static void freeTableCachedVal(void* param) {




×







543



  if (param == NULL) {




×







544



    return;




×







545



  }










546












547



  STableCachedVal* pVal = param;




×







548



  taosMemoryFree((void*)pVal->pName);




×







549



  taosMemoryFree(pVal->pTags);




×







550



  taosMemoryFree(pVal);




×







551



}










552












553



static int32_t createTableCacheVal(const SMetaReader* pMetaReader, STableCachedVal** ppResVal) {




×







554



  int32_t          code = TSDB_CODE_SUCCESS;




×







555



  int32_t          lino = 0;




×







556



  STableCachedVal* pVal = taosMemoryMalloc(sizeof(STableCachedVal));




×







557



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




×







558












559



  pVal->pTags = NULL;




×







560



  pVal->pName = taosStrdup(pMetaReader->me.name);




×







561



  QUERY_CHECK_NULL(pVal->pName, code, lino, _end, terrno);




×







562












563



  // only child table has tag value










564



  if (pMetaReader->me.type == TSDB_CHILD_TABLE || pMetaReader->me.type == TSDB_VIRTUAL_CHILD_TABLE) {




×







565



    STag* pTag = (STag*)pMetaReader->me.ctbEntry.pTags;




×







566



    pVal->pTags = taosMemoryMalloc(pTag->len);




×







567



    QUERY_CHECK_NULL(pVal->pTags, code, lino, _end, terrno);




×







568



    memcpy(pVal->pTags, pTag, pTag->len);




×







569



  }










570












571



  (*ppResVal) = pVal;




×







572












573



_end:




×







574



  if (code != TSDB_CODE_SUCCESS) {




×







575



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




×







576



    freeTableCachedVal(pVal);




×







577



  }










578



  return code;




×







579



}










580












581



// const void *key, size_t keyLen, void *value










582



static void freeCachedMetaItem(const void* key, size_t keyLen, void* value, void* ud) {




×







583



  (void)key;










584



  (void)keyLen;










585



  (void)ud;










586



  freeTableCachedVal(value);




×







587



}




×







588












589



static void doSetNullValue(SSDataBlock* pBlock, const SExprInfo* pExpr, int32_t numOfExpr) {




×







590



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




×







591



    int32_t dstSlotId = pExpr[j].base.resSchema.slotId;




×







592












593



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




×







594



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




×







595



  }










596



}




×







597












598



static void freeTableCachedValObj(STableCachedVal* pVal) {




×







599



  taosMemoryFree((void*)pVal->pName);




×







600



  taosMemoryFree(pVal->pTags);




×







601



}




×







602












603



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




390,764,467✔





604



                               int32_t rows, SExecTaskInfo* pTask, STableMetaCacheInfo* pCache) {










605



  int32_t          code = TSDB_CODE_SUCCESS;




390,764,467✔





606



  int32_t          lino = 0;




390,764,467✔





607



  bool             freeReader = false;




390,764,467✔





608



  LRUHandle*       h = NULL;




390,764,467✔





609



  STableCachedVal  val = {0};




390,764,467✔





610



  SMetaReader      mr = {0};




390,764,467✔





611



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




390,816,054✔





612



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




390,860,157✔





613



  STableCachedVal* pVal = NULL;




390,860,157✔





614












615



  // currently only the tbname pseudo column










616



  if (numOfExpr <= 0) {




390,891,403✔





617



    return TSDB_CODE_SUCCESS;




288,078✔





618



  }










619












620



  // todo: opt if only require the vgId and the vgVer;










621












622



  // backup the rows










623



  int32_t backupRows = pBlock->info.rows;




390,603,325✔





624



  pBlock->info.rows = rows;




390,590,038✔





625












626



  // todo refactor: extract method










627



  // the handling of the null data should be packed in the extracted method










628












629



  // 1. check if it is existed in meta cache










630



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




390,656,946✔





631



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




390,652,968✔





632



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




390,684,120✔





633



    if (code != TSDB_CODE_SUCCESS) {




390,374,880✔





634



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.










635



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







636



        qWarn("failed to get table meta, table may have been dropped, uid:0x%" PRIx64 ", code:%s, %s",




×







637



              pBlock->info.id.uid, tstrerror(code), idStr);










638












639



        // append null value before return to caller, since the caller will ignore this error code and proceed










640



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







641



      } else {










642



        qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.id.uid, tstrerror(code), idStr);




×







643



      }










644



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




×







645



      return code;




×







646



    }










647












648



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




390,374,880✔





649












650



    val.pName = mr.me.name;




390,646,431✔





651



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




390,646,431✔





652












653



    freeReader = true;




390,646,431✔





654



  } else {










655



    pCache->metaFetch += 1;




×







656












657



    h = taosLRUCacheLookup(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(pBlock->info.id.uid));




×







658



    if (h == NULL) {




×







659



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




×







660



      freeReader = true;




×







661



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




×







662



      if (code != TSDB_CODE_SUCCESS) {




×







663



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







664



          qWarn("failed to get table meta, table may have been dropped, uid:0x%" PRIx64 ", code:%s, %s",




×







665



                pBlock->info.id.uid, tstrerror(code), idStr);










666



          // append null value before return to caller, since the caller will ignore this error code and proceed










667



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







668



        } else {










669



          qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.id.uid, tstrerror(code),




×







670



                 idStr);










671



        }










672



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




×







673



        return code;




×







674



      }










675












676



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




×







677












678



      code = createTableCacheVal(&mr, &pVal);




×







679



      QUERY_CHECK_CODE(code, lino, _end);




×







680












681



      val = *pVal;




×







682



    } else {










683



      pCache->cacheHit += 1;




×







684



      STableCachedVal* pValTmp = taosLRUCacheValue(pCache->pTableMetaEntryCache, h);




×







685



      val = *pValTmp;




×







686












687



      bool bRes = taosLRUCacheRelease(pCache->pTableMetaEntryCache, h, false);




×







688



      qTrace("release LRU cache, res %d", bRes);




×







689



    }










690












691



    qDebug("retrieve table meta from cache:%" PRIu64 ", hit:%" PRIu64 " miss:%" PRIu64 ", %s", pCache->metaFetch,




×







692



           pCache->cacheHit, (pCache->metaFetch - pCache->cacheHit), idStr);










693



  }










694












695



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




1,564,980,877✔





696



    const SExprInfo* pExpr1 = &pExpr[j];




1,174,245,670✔





697



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




1,174,284,706✔





698












699



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




1,174,441,443✔





700



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




1,174,513,866✔





701












702



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




1,174,527,135✔





703












704



    // this is to handle the tbname










705



    if (fmIsScanPseudoColumnFunc(functionId)) {




1,174,552,786✔





706



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




130,788,379✔





707



      if (fType == FUNCTION_TYPE_TBNAME) {




130,799,302✔





708



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




130,799,302✔





709



        QUERY_CHECK_CODE(code, lino, _end);




130,783,666✔





710



      } else if (fType == FUNCTION_TYPE_VGID) {




×







711



        code = setVgIdColData(pBlock, pColInfoData, functionId, pTask->id.vgId);




×







712



        QUERY_CHECK_CODE(code, lino, _end);




×







713



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







714



        code = setVgVerColData(pBlock, pColInfoData, functionId, pBlock->info.version);




×







715



        QUERY_CHECK_CODE(code, lino, _end);




×







716



      }










717



    } else {  // these are tags










718



      STagVal tagVal = {0};




1,043,476,664✔





719



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




1,043,495,738✔





720



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




1,043,736,881✔





721












722



      char* data = NULL;




1,043,730,381✔





723



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




1,043,730,381✔





724



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




1,038,805,210✔





725



      } else {










726



        data = (char*)p;




5,004,451✔





727



      }










728












729



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




1,043,536,183✔





730



      if (isNullVal) {




1,043,536,688✔





731



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




4,527,039✔





732



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




1,039,009,649✔





733



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




1,038,645,274✔





734



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




1,038,699,606✔





735



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




376,941,841✔





736



          if (tmp != NULL) {




376,984,289✔





737



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




376,984,289✔





738



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




376,961,377✔





739



                   pBlock->info.id.uid);










740



            taosMemoryFree(tmp);




377,045,921✔





741



          }










742



          taosMemoryFree(data);




377,042,683✔





743



        }










744



        QUERY_CHECK_CODE(code, lino, _end);




1,038,557,790✔





745



      } else {  // todo opt for json tag










746



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




2,970,786✔





747



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




2,493,374✔





748



          QUERY_CHECK_CODE(code, lino, _end);




2,493,374✔





749



        }










750



      }










751



    }










752



  }










753












754



  // restore the rows










755



  pBlock->info.rows = backupRows;




390,735,207✔





756












757



_end:




390,616,238✔





758












759



  if (NULL != pVal) {




390,651,336✔





760



    insertRet =




×







761



        taosLRUCacheInsert(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(uint64_t), pVal,




×







762



                           sizeof(STableCachedVal), freeCachedMetaItem, NULL, NULL, TAOS_LRU_PRIORITY_LOW, NULL);










763



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







764



      qWarn("failed to put meta into lru cache, code:%d, %s", insertRet, idStr);




×







765



    }










766



  }










767












768



  if (freeReader) {




390,651,336✔





769



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




390,564,109✔





770



  }










771



  if (code != TSDB_CODE_SUCCESS) {




390,656,520✔





772



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




×







773



  }










774



  return code;




390,530,074✔





775



}










776












777



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




130,779,958✔





778



                         const char* name) {










779



  int32_t                     code = TSDB_CODE_SUCCESS;




130,779,958✔





780



  int32_t                     lino = 0;




130,779,958✔





781



  struct SScalarFuncExecFuncs fpSet = {0};




130,779,958✔





782



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




130,787,063✔





783



  QUERY_CHECK_CODE(code, lino, _end);




130,785,349✔





784












785



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




130,785,349✔





786



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




130,785,349✔





787



  STR_TO_VARSTR(buf, name)




130,789,980✔





788












789



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




130,780,039✔





790












791



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




130,773,674✔





792



  QUERY_CHECK_CODE(code, lino, _end);




130,801,497✔





793












794



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




130,801,497✔





795



  QUERY_CHECK_CODE(code, lino, _end);




130,793,582✔





796












797



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




130,793,582✔





798



  SScalarParam param = {.columnData = pColInfoData};




130,796,807✔





799












800



  if (fpSet.process != NULL) {




130,782,750✔





801



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




130,782,750✔





802



    QUERY_CHECK_CODE(code, lino, _end);




130,799,327✔





803



  } else {










804



    qError("failed to get the corresponding callback function, functionId:%d", functionId);




×







805



  }










806












807



  colDataDestroy(&infoData);




130,799,327✔





808












809



_end:




130,763,103✔





810



  if (code != TSDB_CODE_SUCCESS) {




130,788,603✔





811



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




×







812



  }










813



  return code;




130,788,603✔





814



}










815












816



int32_t setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId) {




×







817



  int32_t                     code = TSDB_CODE_SUCCESS;




×







818



  int32_t                     lino = 0;




×







819



  struct SScalarFuncExecFuncs fpSet = {0};




×







820



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







821



  QUERY_CHECK_CODE(code, lino, _end);




×







822












823



  SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1);




×







824












825



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




×







826



  QUERY_CHECK_CODE(code, lino, _end);




×







827












828



  code = colDataSetVal(&infoData, 0, (const char*)&vgId, false);




×







829



  QUERY_CHECK_CODE(code, lino, _end);




×







830












831



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




×







832



  SScalarParam param = {.columnData = pColInfoData};




×







833












834



  if (fpSet.process != NULL) {




×







835



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




×







836



    QUERY_CHECK_CODE(code, lino, _end);




×







837



  } else {










838



    qError("failed to get the corresponding callback function, functionId:%d", functionId);




×







839



  }










840












841



_end:




×







842



  colDataDestroy(&infoData);




×







843



  if (code != TSDB_CODE_SUCCESS) {




×







844



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




×







845



  }










846



  return code;




×







847



}










848












849



int32_t setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer) {




×







850



  int32_t                     code = TSDB_CODE_SUCCESS;




×







851



  int32_t                     lino = 0;




×







852



  struct SScalarFuncExecFuncs fpSet = {0};




×







853



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







854



  QUERY_CHECK_CODE(code, lino, _end);




×







855












856



  SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1);




×







857












858



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




×







859



  QUERY_CHECK_CODE(code, lino, _end);




×







860












861



  code = colDataSetVal(&infoData, 0, (const char*)&vgVer, false);




×







862



  QUERY_CHECK_CODE(code, lino, _end);




×







863












864



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




×







865



  SScalarParam param = {.columnData = pColInfoData};




×







866












867



  if (fpSet.process != NULL) {




×







868



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




×







869



    QUERY_CHECK_CODE(code, lino, _end);




×







870



  } else {










871



    qError("failed to get the corresponding callback function, functionId:%d", functionId);




×







872



  }










873












874



_end:




×







875



  colDataDestroy(&infoData);




×







876



  if (code != TSDB_CODE_SUCCESS) {




×







877



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




×







878



  }










879



  return code;




×







880



}










881












882



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




329,739,158✔





883



  int32_t code = TSDB_CODE_SUCCESS;




329,739,158✔





884



  int32_t lino = 0;




329,739,158✔





885



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




329,739,158✔





886



  QUERY_CHECK_CODE(code, lino, _end);




329,691,054✔





887












888



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




329,691,054✔





889



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




329,917,419✔





890



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




329,435,938✔





891



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




329,678,337✔





892












893



  if (!pInfo->needCountEmptyTable) {




329,512,660✔





894



    pInfo->countState = TABLE_COUNT_STATE_END;




307,885,441✔





895



  } else {










896



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




21,866,460✔





897



  }










898












899



_end:




329,714,230✔





900



  if (code != TSDB_CODE_SUCCESS) {




329,714,230✔





901



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




×







902



  }










903



  return code;




329,738,996✔





904



}










905












906



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




713,210,992✔





907



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




713,210,992✔





908



    return;




597,057,002✔





909



  }










910



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




116,260,859✔





911



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




220,556✔





912



  } else {










913



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




116,038,722✔





914



    if (code != TSDB_CODE_SUCCESS) {




116,046,941✔





915



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




50,396,558✔





916



    }










917



  }










918



}










919












920



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




45,069,932✔





921



                                         const STableKeyInfo* tbInfo) {










922



  blockDataEmpty(pBlock);




45,069,932✔





923



  pBlock->info.rows = 1;




45,074,435✔





924



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




45,074,435✔





925



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




45,073,944✔





926



  pBlock->info.blankFill = true;




45,074,842✔





927












928



  // only one row: set all col data to null & hasNull










929



  int32_t col_num = blockDataGetNumOfCols(pBlock);




45,075,333✔





930



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




186,356,924✔





931



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




141,283,555✔





932



    colDataSetNULL(pColInfoData, 0);










933



  }










934












935



  // set tag/tbname










936



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




45,073,369✔





937












938



  return pBlock;




45,064,531✔





939



}










940












941



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




43,297,656✔





942



  STableScanInfo* pTableScanInfo = pOperator->info;




43,297,656✔





943



  SSDataBlock*    pBlock =










944



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




43,306,003✔





945












946



  pOperator->resultInfo.totalRows++;




43,292,255✔





947



  return pBlock;




43,309,931✔





948



}










949












950



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




981,451,081✔





951



  int32_t         code = TSDB_CODE_SUCCESS;




981,451,081✔





952



  int32_t         lino = 0;




981,451,081✔





953



  STableScanInfo* pTableScanInfo = pOperator->info;




981,451,081✔





954



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




981,837,107✔





955



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




981,579,260✔





956



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




981,900,442✔





957



  bool            hasNext = false;




981,775,526✔





958



  int64_t         st = taosGetTimestampUs();




981,634,690✔





959












960



  QRY_PARAM_CHECK(ppRes);




981,634,690✔





961



  pBlock->info.dataLoad = false;




981,853,951✔





962












963



  while (true) {




26,949,857✔





964



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




1,008,509,045✔





965



    if (code != TSDB_CODE_SUCCESS) {




1,008,586,131✔





966



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




×








UNCOV

967



      QUERY_CHECK_CODE(code, lino, _end);




×







968



    }










969












970



    if (!hasNext) {




1,008,564,197✔





971



      break;




305,605,916✔





972



    }










973












974



    if (isTaskKilled(pTaskInfo)) {




702,958,281✔





975



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




31,881✔





976



      code = pTaskInfo->code;




31,881✔





977



      goto _end;




31,881✔





978



    }










979












980



    if (pOperator->status == OP_EXEC_DONE) {




703,346,260✔





981



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




89,376✔





982



      break;




89,376✔





983



    }










984












985



    // process this data block based on the probabilities










986



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




703,015,280✔





987



    if (!processThisBlock) {




703,011,962✔






UNCOV

988



      continue;




×







989



    }










990












991



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




703,011,962✔





992



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




703,164,843✔





993



    }










994












995



    uint32_t status = 0;




703,372,687✔





996



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




703,391,078✔





997



    QUERY_CHECK_CODE(code, lino, _end);




702,849,203✔





998












999



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




699,869,101✔





1000



      break;




2,896,280✔





1001



    }










1002












1003



    // current block is filter out according to filter condition, continue load the next block










1004



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




696,972,821✔





1005



      continue;




26,950,765✔





1006



    }










1007












1008



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




669,732,674✔





1009



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




670,089,508✔





1010












1011



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




670,499,799✔





1012



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




670,533,407✔





1013












1014



    (*ppRes) = pBlock;




670,423,319✔





1015



    return code;




669,770,013✔





1016



  }










1017












1018



_end:




311,625,797✔





1019



  if (code != TSDB_CODE_SUCCESS) {




311,644,337✔





1020



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




3,074,583✔





1021



    pTaskInfo->code = code;




3,074,583✔





1022



    T_LONG_JMP(pTaskInfo->env, code);




3,012,437✔





1023



  }










1024



  return code;




308,569,754✔





1025



}










1026












1027



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




1,035,151,978✔





1028



  int32_t         code = TSDB_CODE_SUCCESS;




1,035,151,978✔





1029



  int32_t         lino = 0;




1,035,151,978✔





1030



  STableScanInfo* pTableScanInfo = pOperator->info;




1,035,151,978✔





1031



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




1,035,457,322✔





1032



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




1,035,170,317✔





1033












1034



  QRY_PARAM_CHECK(pBlock);




1,034,789,889✔





1035












1036



  // The read handle is not initialized yet, since no qualified tables exists










1037



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




1,035,260,769✔





1038



    return code;




10,404,931✔





1039



  }










1040












1041



  // do the ascending order traverse in the first place.










1042



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




1,318,533,594✔





1043



    SSDataBlock* p = NULL;




895,288,025✔





1044



    code = doTableScanImplNext(pOperator, &p);




895,214,311✔





1045



    QUERY_CHECK_CODE(code, lino, _end);




891,942,189✔





1046












1047



    if (p != NULL) {




891,942,189✔





1048



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




598,337,018✔





1049



      *pBlock = p;




598,459,155✔





1050



      return code;




598,003,711✔





1051



    }










1052












1053



    pTableScanInfo->scanTimes += 1;




293,605,171✔





1054



    taosHashClear(pTableScanInfo->pIgnoreTables);




293,607,093✔





1055












1056



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




293,636,105✔





1057



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




84,360✔





1058



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




84,360✔





1059



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




84,360✔





1060



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




84,360✔





1061












1062



      // do prepare for the next round table scan operation










1063



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




84,360✔





1064



      QUERY_CHECK_CODE(code, lino, _end);




77,832✔





1065



    }










1066



  }










1067












1068



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




423,373,373✔





1069



  if (pTableScanInfo->scanTimes < total) {




423,403,517✔





1070



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




86,550,463✔





1071



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




65,728✔





1072



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




65,728✔





1073



      QUERY_CHECK_CODE(code, lino, _end);




65,728✔





1074



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




65,728✔





1075



    }










1076












1077



    while (pTableScanInfo->scanTimes < total) {




101,457,206✔





1078



      SSDataBlock* p = NULL;




86,565,215✔





1079



      code = doTableScanImplNext(pOperator, &p);




86,549,393✔





1080



      QUERY_CHECK_CODE(code, lino, _end);




86,484,287✔





1081












1082



      if (p != NULL) {




86,484,287✔





1083



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




71,541,122✔





1084



        *pBlock = p;




71,539,666✔





1085



        return code;




71,544,502✔





1086



      }










1087












1088



      pTableScanInfo->scanTimes += 1;




14,943,165✔





1089



      taosHashClear(pTableScanInfo->pIgnoreTables);




14,946,456✔





1090












1091



      if (pTableScanInfo->scanTimes < total) {




14,945,219✔





1092



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1093



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1094












1095



        qDebug("%s start to repeat descending order scan data blocks", GET_TASKID(pTaskInfo));




×







1096



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




×







1097



        QUERY_CHECK_CODE(code, lino, _end);




102✔





1098



      }










1099



    }










1100



  }










1101












1102



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




351,623,622✔





1103



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




64,411,746✔





1104



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




64,416,740✔





1105



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




117,497✔





1106



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




3,952✔





1107



        STableKeyInfo* pStart =










1108



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




3,952✔





1109












1110



        if (NULL == pStart) {




3,952✔





1111



          return code;




×







1112



        }










1113












1114



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




3,952✔





1115



        return code;




3,952✔





1116



      }










1117



    } else {  // group by tag + no sort










1118



      int32_t numOfTables = 0;




64,310,665✔





1119



      code = tableListGetSize(pTableListInfo, &numOfTables);




64,310,994✔





1120



      QUERY_CHECK_CODE(code, lino, _end);




64,312,580✔





1121












1122



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




64,312,580✔





1123



        // get empty group, mark processed & rm from hash










1124



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




62,636,980✔





1125



        if (pIte != NULL) {




62,634,580✔





1126



          size_t        keySize = 0;




43,304,183✔





1127



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




43,304,674✔





1128



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




43,304,015✔





1129



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




43,305,979✔





1130



          markGroupProcessed(pTableScanInfo, *pGroupId);




43,304,015✔





1131



          *pBlock = getBlockForEmptyTable(pOperator, &info);




43,298,614✔





1132












1133



          return code;




43,298,614✔





1134



        }










1135



      }










1136



    }










1137



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




21,119,976✔





1138



  }










1139












1140



_end:




287,352,028✔





1141



  if (code != TSDB_CODE_SUCCESS) {




308,442,426✔





1142



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




×







1143



    pTaskInfo->code = code;




×







1144



  }










1145












1146



  return code;




308,442,426✔





1147



}










1148












1149



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




42,392,514✔





1150



  STableScanInfo*          pInfo = pOperator->info;




42,392,514✔





1151



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




42,392,514✔





1152



  int32_t                  code = 0;




42,392,514✔





1153



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




42,392,514✔





1154



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




42,392,514✔





1155



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




42,392,514✔





1156



  if (num <= 0) {




42,392,514✔





1157



    qError("empty table scan uid list");




×







1158



    return TSDB_CODE_INVALID_PARA;




×







1159



  }










1160












1161



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




42,392,514✔





1162



         pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










1163



         pOperator->status);










1164












1165



  if (pParam->tableSeq) {




42,392,514✔





1166



    pListInfo->oneTableForEachGroup = true;




42,155,640✔





1167



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




42,155,640✔





1168



      taosHashClear(pListInfo->map);




×







1169



      taosArrayClear(pListInfo->pTableList);




×







1170



      pOperator->status = OP_EXEC_DONE;




×







1171



    }










1172



  } else {










1173



    pListInfo->oneTableForEachGroup = false;




236,874✔





1174



    pListInfo->numOfOuputGroups = 1;




236,874✔





1175



  }










1176



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




42,392,514✔





1177



    // do nothing










1178



  } else {










1179



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




42,151,260✔





1180



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




42,151,260✔





1181



  }










1182












1183



  STableKeyInfo info = {.groupId = 0};




42,392,514✔





1184



  int32_t       tableIdx = 0;




42,392,514✔





1185



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




91,917,344✔





1186



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




49,524,830✔





1187



    if (!pUid) {




49,524,830✔





1188



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







1189



      return terrno;




×







1190



    }










1191












1192



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




49,524,830✔





1193



      if (TSDB_CODE_DUP_KEY == terrno) {




6,787,957✔





1194



        continue;




6,787,957✔





1195



      }










1196



      return terrno;




×







1197



    }










1198












1199



    info.uid = *pUid;




42,736,873✔





1200



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




42,736,873✔





1201



    if (p == NULL) {




42,736,873✔





1202



      return terrno;




×







1203



    }










1204












1205



    tableIdx++;




42,736,873✔





1206



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




42,736,873✔





1207



  }










1208












1209



  return code;




42,392,514✔





1210



}










1211












1212



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




274,087,874✔





1213



                            STableKeyInfo** pList) {










1214



  const char* idStr = GET_TASKID(pTaskInfo);




274,087,874✔





1215



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




274,273,567✔





1216



  if (code) {




273,618,989✔





1217



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




×







1218



    return code;




×







1219



  }










1220












1221



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




273,618,989✔





1222



    qError("%s tsdb reader should be null", idStr);




×







1223



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1224



  }










1225












1226



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




548,047,882✔





1227



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




274,085,976✔





1228



  if (code) {




274,188,646✔





1229



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




2,170✔





1230



  }










1231












1232



  return code;




274,265,099✔





1233



}










1234












1235



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




305,661,752✔





1236



  SColIdPair* node1 = (SColIdPair*)elem1;




305,661,752✔





1237



  SColIdPair* node2 = (SColIdPair*)elem2;




305,661,752✔





1238












1239



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




305,661,752✔





1240



    return 0;




107,560✔





1241



  }










1242












1243



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




305,646,780✔





1244



}










1245












1246



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




305,640,022✔





1247



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




305,640,022✔





1248



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




305,640,022✔





1249












1250



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




305,640,022✔





1251



    return 0;




107,560✔





1252



  }










1253












1254



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




305,617,127✔





1255



}










1256












1257



static bool isNewScanParam(STableScanOperatorParam* pParam) {




45,617,844✔





1258



  return pParam->isNewParam;




45,617,844✔





1259



}










1260












1261



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




15,527,331✔





1262



  int32_t                  code = 0;




15,527,331✔





1263



  int32_t                  lino = 0;




15,527,331✔





1264



  STableScanInfo*          pInfo = pOperator->info;




15,527,331✔





1265



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




15,529,179✔





1266



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




15,525,553✔





1267



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




15,526,294✔





1268



  SMetaReader              orgTable = {0};




15,528,749✔





1269



  SMetaReader              superTable = {0};




15,543,250✔





1270



  SSchemaWrapper*          schema = NULL;




15,532,671✔





1271



  SArray*                  pColArray = NULL;




15,532,671✔





1272



  SArray*                  pBlockColArray = NULL;




15,532,671✔





1273



  int32_t                  num = 0;




15,532,671✔





1274



  STableKeyInfo*           pList = NULL;




15,530,768✔





1275



  SOrgTbInfo*              pOrgTbInfo;










1276



  bool                     isNewTable;










1277












1278



  cleanupQueryTableDataCond(&pInfo->base.cond);




15,533,232✔





1279












1280



  if (pOperator->pOperatorGetParam) {




15,533,061✔





1281



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




3,704,433✔





1282



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




3,711,130✔





1283



    pParam->pBatchTbInfo = NULL;




3,704,927✔





1284



    pInfo->cachedTimeWindow = pParam->window;




3,701,548✔





1285



    pInfo->currentBatchIdx = 0;




3,703,021✔





1286



    pInfo->lastBatchIdx = -1;




3,703,805✔





1287



    pInfo->cachedTagList = pParam->pTagList;




3,708,175✔





1288



    pParam->pTagList = NULL;




3,703,076✔





1289



    pInfo->cachedGroupId = pParam->groupid;




3,688,447✔





1290












1291



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




3,703,997✔





1292



           pTaskInfo->id.vgId, taosArrayGetSize(pInfo->pBatchColMap), pInfo->cachedGroupId, GET_TASKID(pTaskInfo));










1293



    taosHashClear(pInfo->pIgnoreTables);




3,703,997✔





1294












1295



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




3,709,956✔





1296



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




3,710,880✔





1297



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




46,663,549✔





1298



        SqlFunctionCtx ctx = pSup->pCtx[i];




42,965,258✔





1299



        ctx.skipDynDataCheck = false;




42,953,526✔





1300



      }










1301



    }










1302



  }










1303












1304



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




15,526,120✔





1305



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




15,540,920✔





1306












1307



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




15,540,920✔





1308



    isNewTable = false;




9,671,587✔





1309



  } else {










1310



    isNewTable = true;




5,870,431✔





1311



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




5,870,431✔





1312



  }










1313












1314



  if (isNewTable) {




15,537,544✔





1315



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




5,866,265✔





1316



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




5,871,047✔





1317



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




5,857,263✔





1318



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




5,858,187✔





1319



    QUERY_CHECK_CODE(code, lino, _return);




5,857,513✔





1320



    switch (orgTable.me.type) {




5,857,513✔





1321



      case TSDB_CHILD_TABLE:




35,135✔





1322



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




35,135✔





1323



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




35,135✔





1324



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




35,135✔





1325



        QUERY_CHECK_CODE(code, lino, _return);




35,135✔





1326



        schema = &superTable.me.stbEntry.schemaRow;




35,135✔





1327



        break;




35,135✔





1328



      case TSDB_NORMAL_TABLE:




5,790,891✔





1329



        schema = &orgTable.me.ntbEntry.schemaRow;




5,790,891✔





1330



        break;




5,790,891✔





1331



      default:




31,487✔





1332



        qError("invalid table type:%d", orgTable.me.type);




31,487✔





1333



        return TSDB_CODE_INVALID_PARA;




×







1334



        break;










1335



    }










1336












1337



    pListInfo->oneTableForEachGroup = true;




5,826,026✔





1338



    taosHashClear(pListInfo->map);




5,861,816✔





1339



    taosArrayClear(pListInfo->pTableList);




5,874,185✔





1340












1341



    uint64_t      pUid = orgTable.me.uid;




5,873,386✔





1342



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




5,873,386✔





1343



    int32_t       tableIdx = 0;




5,873,386✔





1344



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




5,873,386✔





1345



    QUERY_CHECK_CODE(code, lino, _return);




5,873,694✔





1346



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




11,744,683✔





1347



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




5,870,989✔





1348












1349



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




5,870,989✔





1350



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




5,868,159✔





1351



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




5,868,159✔





1352



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




5,868,900✔





1353












1354



    // virtual table's origin table scan do not has ts column.










1355



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




5,868,900✔





1356



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




5,870,681✔





1357












1358



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




23,306,408✔





1359



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




17,434,745✔





1360



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




141,586,428✔





1361



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




141,344,975✔





1362



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




17,435,419✔





1363



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




17,438,557✔





1364



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




17,438,557✔





1365



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1366



          break;




17,433,513✔





1367



        }










1368



      }










1369



    }










1370












1371



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




29,183,115✔





1372



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




23,305,334✔





1373



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




145,352,025✔





1374



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




145,177,891✔





1375



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




145,202,312✔





1376



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




23,305,725✔





1377



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




23,311,943✔





1378



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




23,311,943✔





1379



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1380



          break;




23,296,204✔





1381



        }










1382



      }










1383



    }










1384












1385



    taosArraySort(pColArray, compareColIdPair);




5,871,230✔





1386



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




5,867,110✔





1387



    if (pInfo->pBlockColMap) {




5,869,083✔





1388



      taosArrayDestroy(pInfo->pBlockColMap);




4,168,513✔





1389



      pInfo->pBlockColMap = NULL;




4,161,447✔





1390



    }










1391



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




5,864,289✔





1392



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




5,866,927✔





1393












1394












1395



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




5,854,609✔





1396



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




5,861,825✔





1397












1398



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




5,871,205✔





1399



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




5,864,072✔





1400



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




72,722,937✔





1401



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




66,865,699✔





1402



        bool           needScan = false;




66,849,386✔





1403



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




134,613,679✔





1404



          SFunctParam pParam = ctx->param[j];




67,740,472✔





1405



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




324,944,124✔





1406



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




273,093,744✔





1407



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




273,834,847✔





1408



              needScan |= true;




16,874,909✔





1409



              break;




16,874,909✔





1410



            }










1411



          }










1412



        }










1413



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




66,868,386✔





1414



        if (!needScan) {




66,913,261✔





1415



          ctx->skipDynDataCheck = true;




50,043,945✔





1416



        } else {










1417



          ctx->skipDynDataCheck = false;




16,869,316✔





1418



        }










1419



      }










1420



    }










1421












1422












1423



  } else {










1424



    pColArray = pInfo->lastColArray;




9,671,279✔





1425



    pBlockColArray = pInfo->lastBlockColArray;




9,671,587✔





1426



  }










1427












1428



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




15,542,085✔





1429



  QUERY_CHECK_CODE(code, lino, _return);




15,545,156✔





1430












1431



  if (pInfo->pResBlock) {




15,545,156✔





1432



    blockDataDestroy(pInfo->pResBlock);




11,830,647✔





1433



    pInfo->pResBlock = NULL;




11,830,647✔





1434



  }










1435












1436



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




15,545,464✔





1437



         "cachedTimeWindow:[%" PRId64 ", %" PRId64 "] , "










1438



         "orgCondWindow: :[%" PRId64 ", %" PRId64 "], %s",










1439



         isNewTable, pInfo->base.orgCond.order,










1440



         pInfo->lastTimeWindow.skey, pInfo->lastTimeWindow.ekey,










1441



         pInfo->cachedTimeWindow.skey, pInfo->cachedTimeWindow.ekey,










1442



         pInfo->base.orgCond.twindows.skey, pInfo->base.orgCond.twindows.ekey, GET_TASKID(pTaskInfo));










1443












1444



  if (isNewTable) {




15,535,559✔





1445



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




5,863,664✔





1446



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




5,861,026✔





1447



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




5,864,829✔





1448



    } else {










1449



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




4,120✔





1450



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




×







1451



    }










1452



  } else {










1453



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




9,671,895✔





1454



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




1,345,133✔





1455



    else {










1456



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




8,326,762✔





1457



    }










1458



  }










1459












1460



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




15,532,171✔





1461



  pInfo->currentGroupId = 0;




15,514,851✔





1462



  pInfo->ignoreTag = true;




15,515,527✔





1463












1464



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




15,510,700✔





1465



  QUERY_CHECK_CODE(code, lino, _return);




15,532,729✔





1466












1467



  if (isNewTable) {




15,532,729✔





1468



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




5,861,450✔





1469



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




4,165,616✔





1470



    }










1471



    pInfo->base.dataReader = NULL;




5,841,542✔





1472












1473



    taosRLockLatch(&pTaskInfo->lock);




5,843,256✔





1474



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




5,856,406✔





1475



    taosRUnLockLatch(&pTaskInfo->lock);




5,834,881✔





1476



    QUERY_CHECK_CODE(code, lino, _return);




5,858,446✔





1477












1478



    pInfo->newReader = true;




5,858,446✔





1479



    if (pInfo->lastColArray) {




5,860,044✔





1480



      taosArrayDestroy(pInfo->lastColArray);




2,158,752✔





1481



      pInfo->lastColArray = NULL;




2,158,261✔





1482



    }










1483



    if (pInfo->lastBlockColArray) {




5,849,831✔





1484



      taosArrayDestroy(pInfo->lastBlockColArray);




2,158,752✔





1485



      pInfo->lastBlockColArray = NULL;




2,158,752✔





1486



    }










1487



    pInfo->lastColArray = pColArray;




5,860,834✔





1488



    pInfo->lastBlockColArray = pBlockColArray;




5,857,330✔





1489



  } else {










1490



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




9,671,279✔





1491



    QUERY_CHECK_CODE(code, lino, _return);




9,671,587✔





1492












1493



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




9,671,587✔





1494



    pInfo->newReader = false;




9,671,895✔





1495



    pInfo->scanTimes = 0;




9,671,895✔





1496



  }










1497












1498



  pOperator->status = OP_OPENED;




15,519,556✔





1499












1500



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




15,528,908✔





1501



    pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity;




×







1502



  }










1503












1504



  pInfo->currentGroupId = -1;




15,524,556✔





1505



_return:




15,526,586✔





1506



  if (code) {




15,518,521✔





1507



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




×







1508



  }










1509



  pAPI->metaReaderFn.clearReader(&superTable);




15,518,521✔





1510



  pAPI->metaReaderFn.clearReader(&orgTable);




15,513,704✔





1511



  return code;




15,526,944✔





1512



}










1513












1514



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




26,630,573✔





1515



  int32_t                  code = 0;




26,630,573✔





1516



  int32_t                  lino = 0;




26,630,573✔





1517



  STableScanInfo*          pInfo = pOperator->info;




26,630,573✔





1518



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




26,630,573✔





1519



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




26,630,573✔





1520



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




26,630,573✔





1521



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




26,630,573✔





1522



  SMetaReader              orgTable = {0};




26,630,573✔





1523



  SMetaReader              superTable = {0};




26,630,573✔





1524



  SSchemaWrapper*          schema = NULL;




26,630,573✔





1525



  SArray*                  pColArray = NULL;




26,630,573✔





1526



  SArray*                  pBlockColArray = NULL;




26,630,573✔





1527



  int32_t                  num = 0;




26,630,573✔





1528



  STableKeyInfo*           pList = NULL;




26,630,573✔





1529



  SOrgTbInfo*              pOrgTbInfo;










1530












1531



  cleanupQueryTableDataCond(&pInfo->base.cond);




26,630,573✔





1532












1533



  pOrgTbInfo = pParam->pOrgTbInfo;




26,630,573✔





1534












1535



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




26,630,573✔





1536












1537



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




26,630,573✔





1538



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




26,630,573✔





1539



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




26,630,573✔





1540



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




26,630,573✔





1541



  QUERY_CHECK_CODE(code, lino, _return);




26,630,573✔





1542



  switch (orgTable.me.type) {




26,630,573✔





1543



    case TSDB_CHILD_TABLE:




7,584,474✔





1544



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




7,584,474✔





1545



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




7,584,474✔





1546



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




7,584,474✔





1547



      QUERY_CHECK_CODE(code, lino, _return);




7,584,474✔





1548



      schema = &superTable.me.stbEntry.schemaRow;




7,584,474✔





1549



      break;




7,584,474✔





1550



    case TSDB_NORMAL_TABLE:




19,046,099✔





1551



      schema = &orgTable.me.ntbEntry.schemaRow;




19,046,099✔





1552



      break;




19,046,099✔





1553



    default:




×







1554



      qError("invalid table type:%d", orgTable.me.type);




×







1555



      return TSDB_CODE_INVALID_PARA;




×







1556



      break;










1557



  }










1558












1559



  pListInfo->oneTableForEachGroup = true;




26,630,573✔





1560



  taosHashClear(pListInfo->map);




26,630,573✔





1561



  taosArrayClear(pListInfo->pTableList);




26,630,573✔





1562












1563



  uint64_t      pUid = orgTable.me.uid;




26,630,573✔





1564



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




26,630,573✔





1565



  int32_t       tableIdx = 0;




26,630,573✔





1566



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




26,630,573✔





1567



  QUERY_CHECK_CODE(code, lino, _return);




26,630,573✔





1568



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




53,261,146✔





1569



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




26,630,573✔





1570












1571



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




26,630,573✔





1572



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




26,630,573✔





1573



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




26,630,573✔





1574



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




26,630,573✔





1575












1576



  // virtual table's origin table scan do not has ts column.










1577



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




26,630,573✔





1578



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1579



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1580



                       .type.bytes = 8};










1581



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




26,630,573✔





1582












1583



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




101,656,344✔





1584



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




75,025,771✔





1585



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




614,721,363✔





1586



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




614,721,363✔





1587



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




75,025,771✔





1588



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




75,025,771✔





1589



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




75,025,771✔





1590



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




75,025,771✔





1591



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




75,025,771✔





1592



        break;




75,025,771✔





1593



      }










1594



    }










1595



  }










1596












1597



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




128,286,294✔





1598



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




101,656,344✔





1599



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




608,629,761✔





1600



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




608,629,761✔





1601



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




608,629,761✔





1602



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




101,656,344✔





1603



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




623✔





1604



                 pPair->orgColId, orgTable.me.name);










1605



          code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




623✔





1606



          goto _return;




623✔





1607



        }










1608



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




101,655,721✔





1609



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




101,655,721✔





1610



        break;




101,655,721✔





1611



      }










1612



    }










1613



  }










1614












1615



  taosArraySort(pColArray, compareColIdPair);




26,629,950✔





1616



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




26,629,950✔





1617



  if (pInfo->pBlockColMap) {




26,629,950✔





1618



    taosArrayDestroy(pInfo->pBlockColMap);




24,103,234✔





1619



    pInfo->pBlockColMap = NULL;




24,103,234✔





1620



  }










1621



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




26,629,950✔





1622



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




26,629,950✔





1623












1624



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




26,629,950✔





1625



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




26,629,950✔





1626












1627



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




26,629,950✔





1628



  QUERY_CHECK_CODE(code, lino, _return);




26,629,950✔





1629












1630



  if (pInfo->pResBlock) {




26,629,950✔





1631



    blockDataDestroy(pInfo->pResBlock);




18,990,152✔





1632



    pInfo->pResBlock = NULL;




18,990,152✔





1633



  }










1634












1635



  if (isNewScanParam(pParam)) {




26,629,950✔





1636



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




7,647,432✔





1637



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




7,468,260✔





1638



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




7,468,260✔





1639



    } else {










1640



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




179,172✔





1641



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




179,172✔





1642



    }










1643



  } else {










1644



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




18,982,518✔





1645



  }










1646



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




26,629,950✔





1647



  pInfo->currentGroupId = 0;




26,629,950✔





1648



  pInfo->ignoreTag = true;




26,629,950✔





1649












1650



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




26,629,950✔





1651



  QUERY_CHECK_CODE(code, lino, _return);




26,629,950✔





1652












1653



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




26,629,950✔





1654



  if (reader) {




26,629,950✔





1655



    if (isNewScanParam(pParam)) {




18,987,894✔





1656



      pAPI->tsdReader.tsdReaderClose(*reader);




5,376✔





1657



      pInfo->base.dataReader = NULL;




5,376✔





1658












1659



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




5,376✔





1660



      QUERY_CHECK_CODE(code, lino, _return);




5,376✔





1661












1662



      taosRLockLatch(&pTaskInfo->lock);




5,376✔





1663



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




5,376✔





1664



      taosRUnLockLatch(&pTaskInfo->lock);




5,376✔





1665



      QUERY_CHECK_CODE(code, lino, _return);




5,376✔





1666












1667



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




5,376✔





1668



      QUERY_CHECK_CODE(code, lino, _return);




5,376✔





1669



      pInfo->newReader = true;




5,376✔





1670



    } else {










1671



      pInfo->base.dataReader = *reader;




18,982,518✔





1672



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




18,982,518✔





1673



      QUERY_CHECK_CODE(code, lino, _return);




18,982,518✔





1674












1675



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




18,982,518✔





1676



      pInfo->newReader = false;




18,982,518✔





1677



      pInfo->scanTimes = 0;




18,982,518✔





1678



    }










1679



  } else {










1680



    pInfo->base.dataReader = NULL;




7,642,056✔





1681












1682



    taosRLockLatch(&pTaskInfo->lock);




7,642,056✔





1683



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




7,642,056✔





1684



    taosRUnLockLatch(&pTaskInfo->lock);




7,642,056✔





1685



    QUERY_CHECK_CODE(code, lino, _return);




7,642,056✔





1686












1687



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




7,642,056✔





1688



    QUERY_CHECK_CODE(code, lino, _return);




7,642,056✔





1689



    pInfo->newReader = true;




7,642,056✔





1690



  }










1691



  pOperator->status = OP_OPENED;




26,629,950✔





1692












1693



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




26,629,950✔





1694



    pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity;




×







1695



  }










1696












1697



  pInfo->currentGroupId = -1;




26,629,950✔





1698



_return:




26,630,573✔





1699



  if (code) {




26,630,573✔





1700



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




623✔





1701



  }










1702



  taosArrayDestroy(pColArray);




26,630,573✔





1703



  taosArrayDestroy(pBlockColArray);




26,630,573✔





1704



  pAPI->metaReaderFn.clearReader(&superTable);




26,630,573✔





1705



  pAPI->metaReaderFn.clearReader(&orgTable);




26,630,573✔





1706



  return code;




26,630,573✔





1707



}










1708












1709



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




355,182,225✔





1710



  int32_t         code = TSDB_CODE_SUCCESS;




355,182,225✔





1711



  int32_t         lino = 0;




355,182,225✔





1712



  STableScanInfo* pInfo = pOperator->info;




355,182,225✔





1713



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




355,211,016✔





1714



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




355,189,231✔





1715



  int32_t         numOfTables = 0;




355,226,498✔





1716












1717



  QRY_PARAM_CHECK(pResult);




355,090,232✔





1718












1719



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




355,102,516✔





1720



  QUERY_CHECK_CODE(code, lino, _end);




355,139,363✔





1721












1722



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




355,139,363✔





1723



    setOperatorCompleted(pOperator);




299,550,643✔





1724



    if (pOperator->dynamicTask) {




299,503,079✔





1725



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




47,242,157✔





1726



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




47,242,507✔





1727



    }










1728



    return code;




299,510,909✔





1729



  }










1730












1731



  // reset value for the next group data output










1732



  pOperator->status = OP_OPENED;




55,550,547✔





1733



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




55,599,862✔





1734












1735



  int32_t        num = 0;




55,579,519✔





1736



  STableKeyInfo* pList = NULL;




55,580,318✔





1737



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




55,579,386✔





1738



  QUERY_CHECK_CODE(code, lino, _end);




55,601,759✔





1739












1740



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




55,601,759✔





1741



  QUERY_CHECK_CODE(code, lino, _end);




55,603,174✔





1742












1743



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




55,603,174✔





1744



  QUERY_CHECK_CODE(code, lino, _end);




55,595,824✔





1745



  pInfo->scanTimes = 0;




55,595,824✔





1746












1747



  code = doGroupedTableScan(pOperator, pResult);




55,590,472✔





1748



  QUERY_CHECK_CODE(code, lino, _end);




55,618,806✔





1749












1750



  if (*pResult != NULL) {




55,618,806✔





1751



    if (pOperator->dynamicTask) {




48,597,941✔





1752



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




48,370,723✔





1753



    }










1754



    return code;




48,597,633✔





1755



  }










1756












1757



_end:




7,020,865✔





1758



  if (code != TSDB_CODE_SUCCESS) {




7,021,539✔





1759



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




×







1760



    pTaskInfo->code = code;




×







1761



  }










1762



  return code;




7,021,231✔





1763



}










1764












1765



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




939,506,964✔





1766



  int32_t         code = TSDB_CODE_SUCCESS;




939,506,964✔





1767



  int32_t         lino = 0;




939,506,964✔





1768



  STableScanInfo* pInfo = pOperator->info;




939,506,964✔





1769



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




940,004,838✔





1770



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




939,822,293✔





1771



  int32_t         num = 0;




939,612,555✔





1772



  STableKeyInfo*  pList = NULL;




939,864,464✔





1773



  SSDataBlock*    pResult = NULL;




939,617,826✔





1774



  const char*     idStr = GET_TASKID(pTaskInfo);




939,959,003✔





1775












1776



  QRY_PARAM_CHECK(pResBlock);




939,725,303✔





1777












1778



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




939,799,798✔





1779



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




260,633,392✔





1780



      setOperatorCompleted(pOperator);




×







1781



      return code;




×







1782



    }










1783












1784



    taosRLockLatch(&pTaskInfo->lock);




260,569,861✔





1785



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




260,751,207✔





1786



    taosRUnLockLatch(&pTaskInfo->lock);




260,761,869✔





1787



    QUERY_CHECK_CODE(code, lino, _end);




260,919,320✔





1788












1789



    if (pInfo->filesetDelimited) {




260,917,150✔





1790



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




237,980✔





1791



    }










1792












1793



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




260,917,534✔





1794



      pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity;




×







1795



    }










1796



  }










1797












1798



  code = doGroupedTableScan(pOperator, &pResult);




939,940,955✔





1799



  QUERY_CHECK_CODE(code, lino, _end);




936,515,972✔





1800












1801



  if (pResult != NULL) {




936,515,972✔





1802



    if (pOperator->dynamicTask) {




641,892,395✔





1803



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




1,071,287✔





1804



    }










1805












1806



    *pResBlock = pResult;




641,963,172✔





1807



    return code;




641,625,749✔





1808



  }










1809












1810



  while (true) {










1811



    code = startNextGroupScan(pOperator, &pResult);




294,669,886✔





1812



    QUERY_CHECK_CODE(code, lino, _end);




295,010,881✔





1813












1814



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




295,010,881✔





1815



      *pResBlock = pResult;




294,947,942✔





1816



      return code;




294,927,105✔





1817



    }










1818



  }










1819












1820



_end:




2,170✔





1821



  if (code != TSDB_CODE_SUCCESS) {




2,170✔





1822



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




2,170✔





1823



    pTaskInfo->code = code;




2,170✔





1824



  }










1825












1826



  return code;




2,170✔





1827



}










1828












1829



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




26,629,950✔





1830



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




26,629,950✔





1831



}










1832












1833



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




42,392,514✔





1834



  int32_t                  code = TSDB_CODE_SUCCESS;




42,392,514✔





1835



  int32_t                  lino = 0;




42,392,514✔





1836



  STableScanInfo*          pInfo = pOperator->info;




42,392,514✔





1837



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




42,392,514✔





1838



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




42,392,514✔





1839



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




42,392,514✔





1840












1841



  code = createTableListInfoFromParam(pOperator);




42,392,514✔





1842



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




42,392,514✔





1843



  pOperator->pOperatorGetParam = NULL;




42,392,514✔





1844



  QUERY_CHECK_CODE(code, lino, _end);




42,392,514✔





1845












1846



  if (pOperator->status == OP_EXEC_DONE) {




42,392,514✔





1847



    pInfo->currentGroupId = -1;




41,821,230✔





1848



    pOperator->status = OP_OPENED;




41,821,230✔





1849



    SSDataBlock* result = NULL;




41,821,230✔





1850












1851



    while (true) {










1852



      code = startNextGroupScan(pOperator, &result);




46,672,320✔





1853



      QUERY_CHECK_CODE(code, lino, _end);




46,672,320✔





1854












1855



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




46,672,320✔





1856



        (*ppRes) = result;




41,821,230✔





1857



        return code;




41,821,230✔





1858



      }










1859



    }










1860



  }










1861



_end:




571,284✔





1862



  if (code) {




571,284✔





1863



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




×







1864



  }










1865



  return code;




571,284✔





1866



}










1867












1868



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




26,630,573✔





1869



  int32_t                  code = TSDB_CODE_SUCCESS;




26,630,573✔





1870



  int32_t                  lino = 0;




26,630,573✔





1871



  STableScanInfo*          pInfo = pOperator->info;




26,630,573✔





1872



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




26,630,573✔





1873



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




26,630,573✔





1874



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




26,630,573✔





1875












1876



  QRY_PARAM_CHECK(ppRes);




26,630,573✔





1877



  qTrace("%s call", __FUNCTION__);




26,630,573✔





1878












1879



  code = createVTableScanInfoFromParam(pOperator);




26,630,573✔





1880



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




26,630,573✔





1881



  pOperator->pOperatorGetParam = NULL;




26,630,573✔





1882












1883



  QUERY_CHECK_CODE(code, lino, _end);




26,630,573✔





1884












1885



  SSDataBlock* result = NULL;




26,629,950✔





1886



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




26,629,950✔





1887



    (*ppRes) = result;




18,556✔





1888



    return code;




18,556✔





1889



  }










1890












1891



  if (pInfo->newReader) {




26,611,394✔





1892



    code = startNextGroupScan(pOperator, &result);




7,647,432✔





1893



    QUERY_CHECK_CODE(code, lino, _end);




7,647,432✔





1894



  } else {










1895



    code = doGroupedTableScan(pOperator, &result);




18,963,962✔





1896



    QUERY_CHECK_CODE(code, lino, _end);




18,963,962✔





1897



  }










1898












1899



  if (result) {




26,611,394✔





1900



    SSDataBlock* res = NULL;




18,991,550✔





1901



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




18,991,550✔





1902



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




18,991,550✔





1903



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




18,991,550✔





1904



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




18,991,550✔





1905



    QUERY_CHECK_CODE(code, lino, _end);




18,991,550✔





1906












1907



    pInfo->pResBlock = res;




18,991,550✔





1908



    blockDataDestroy(result);




18,991,550✔





1909



    (*ppRes) = res;




18,991,550✔





1910



  } else {










1911



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




7,619,844✔





1912



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




7,619,844✔





1913












1914



    blockDataDestroy(pInfo->pResBlock);




7,619,844✔





1915



    pInfo->pResBlock = NULL;




7,619,844✔





1916












1917



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




7,619,844✔





1918



    if (reader) {




7,619,844✔





1919



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




7,619,844✔





1920



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




7,619,844✔





1921



        pInfo->base.dataReader = NULL;




7,619,844✔





1922



      }










1923



      if (pAPI->tsdReader.tsdReaderClose) {




7,619,844✔





1924



        pAPI->tsdReader.tsdReaderClose(*reader);




7,619,844✔





1925



      }










1926



    }










1927












1928



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




7,619,844✔





1929



    QUERY_CHECK_CODE(code, lino, _end);




7,619,844✔





1930



  }










1931



_end:




26,612,017✔





1932



  if (code) {




26,612,017✔





1933



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




623✔





1934



  }










1935



  return code;




26,612,017✔





1936



}










1937












1938



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




2,910,880✔





1939



  int32_t                  code = TSDB_CODE_SUCCESS;




2,910,880✔





1940



  int32_t                  lino = 0;




2,910,880✔





1941



  STableScanInfo*          pInfo = pOperator->info;




2,910,880✔





1942



  int32_t                  index = 0;




2,910,880✔





1943



  char*                    tagVal = NULL;




2,910,880✔





1944












1945



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




20,384,265✔





1946



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




17,473,876✔





1947



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




17,472,894✔





1948












1949



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




17,473,385✔





1950



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




17,473,385✔





1951












1952



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




2,147,483,647✔





1953



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





1954



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




2,147,483,647✔





1955



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




2,147,483,647✔





1956












1957



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





1958



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




2,147,483,647✔





1959



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




2,147,483,647✔





1960



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





1961



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





1962



      } else {










1963



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




2,147,483,647✔





1964



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





1965



      }










1966



    }










1967



    index++;




17,473,385✔





1968



  }










1969



  return code;




2,910,880✔





1970



_end:




×







1971



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




×







1972



  taosMemoryFreeClear(tagVal);




×







1973



  return code;




×







1974



}










1975












1976



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




3,714,201✔





1977



  if (pInfo->pBatchColMap) {




3,714,201✔





1978



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




9,588,078✔





1979



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




5,872,337✔





1980



      taosArrayDestroy(pOrgTbInfo->colMap);




5,872,337✔





1981



    }










1982



    taosArrayDestroy(pInfo->pBatchColMap);




3,714,509✔





1983



    pInfo->pBatchColMap = NULL;




3,712,969✔





1984



  }










1985



  if (pInfo->cachedTagList) {




3,713,893✔





1986



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




12,232,940✔





1987



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




10,421,820✔





1988



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




10,421,820✔





1989



        taosMemoryFreeClear(pTagVal->pData);




4,570,112✔





1990



      }










1991



    }










1992



    taosArrayDestroy(pInfo->cachedTagList);




1,809,888✔





1993



    pInfo->cachedTagList = NULL;




1,809,580✔





1994



  }










1995



  if (pInfo->lastColArray) {




3,713,277✔





1996



    taosArrayDestroy(pInfo->lastColArray);




3,713,277✔





1997



    pInfo->lastColArray = NULL;




3,712,969✔





1998



  }










1999



  if (pInfo->lastBlockColArray) {




3,712,969✔





2000



    taosArrayDestroy(pInfo->lastBlockColArray);




3,713,277✔





2001



    pInfo->lastBlockColArray = NULL;




3,711,737✔





2002



  }










2003












2004



  blockDataDestroy(pInfo->pResBlock);




3,711,429✔





2005



  pInfo->pResBlock = NULL;




3,713,585✔





2006



}




3,713,585✔





2007












2008



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




13,376,990✔





2009



  int32_t                  code = TSDB_CODE_SUCCESS;




13,376,990✔





2010



  int32_t                  lino = 0;




13,376,990✔





2011



  STableScanInfo*          pInfo = pOperator->info;




13,376,990✔





2012



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




13,377,298✔





2013



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




13,378,588✔





2014



  SSDataBlock*             result = NULL;




13,375,084✔





2015












2016



  QRY_PARAM_CHECK(ppRes);




13,377,057✔





2017



  qTrace("%s call", __FUNCTION__);




13,379,762✔





2018












2019



  while (!result) {




25,213,114✔





2020



    code = createVTableScanInfoFromBatchParam(pOperator);




15,540,911✔





2021



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




15,518,820✔





2022



    pOperator->pOperatorGetParam = NULL;




15,503,065✔





2023



    QUERY_CHECK_CODE(code, lino, _end);




15,505,871✔





2024












2025



    if (pInfo->newReader) {




15,505,871✔





2026



      code = startNextGroupScan(pOperator, &result);




5,826,208✔





2027



      QUERY_CHECK_CODE(code, lino, _end);




5,868,592✔





2028



    } else {










2029



      code = doGroupedTableScan(pOperator, &result);




9,678,339✔





2030



      QUERY_CHECK_CODE(code, lino, _end);




9,671,279✔





2031



    }










2032



    if (!result) {




15,539,871✔





2033



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




5,870,498✔





2034



             __func__ , pInfo->currentBatchIdx, GET_TASKID(pTaskInfo));










2035



      pInfo->currentBatchIdx++;




5,870,498✔





2036



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




5,870,806✔





2037



        // all batch scan finished










2038



        break;




3,712,661✔





2039



      }










2040



    }










2041



  }










2042












2043



  if (result) {




13,384,864✔





2044



    SSDataBlock* res = NULL;




9,671,895✔





2045



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




9,671,895✔





2046



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




9,671,279✔





2047



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




9,671,279✔





2048












2049



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




9,671,279✔





2050



    QUERY_CHECK_CODE(code, lino, _end);




9,671,895✔





2051












2052



    if (pInfo->cachedTagList) {




9,671,895✔





2053



      code = setTagValFromTagList(pOperator, res);




2,910,880✔





2054



      QUERY_CHECK_CODE(code, lino, _end);




2,910,880✔





2055



    }










2056












2057



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




9,671,895✔





2058



    pInfo->pResBlock = res;




9,671,895✔





2059



    blockDataDestroy(result);




9,671,587✔





2060



    (*ppRes) = res;




9,671,587✔





2061












2062



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




9,671,587✔





2063



  } else {










2064



    clearVstbBatchDynamicTableScanInfo(pInfo);




3,712,969✔





2065



    setOperatorCompleted(pOperator);




3,713,585✔





2066



  }










2067












2068



_end:




13,385,788✔





2069



  return code;




13,386,404✔





2070



}










2071












2072



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




82,398,854✔





2073



  int32_t                  code = TSDB_CODE_SUCCESS;




82,398,854✔





2074



  int32_t                  lino = 0;




82,398,854✔





2075



  STableScanInfo*          pInfo = pOperator->info;




82,398,854✔





2076



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




82,397,872✔





2077



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




82,401,559✔





2078












2079



  QRY_PARAM_CHECK(ppRes);




82,401,376✔





2080



  qTrace("%s call", __FUNCTION__);




82,400,577✔





2081












2082



  pOperator->dynamicTask = true;




82,400,577✔





2083












2084



  switch (type) {




82,406,045✔





2085



    case DYN_TYPE_VSTB_WIN_SCAN:




42,392,514✔





2086



    case DYN_TYPE_STB_JOIN: {










2087



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




42,392,514✔





2088



      QUERY_CHECK_CODE(code, lino, _end);




42,392,514✔





2089



      break;




42,392,514✔





2090



    }










2091



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




26,630,573✔





2092



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




26,630,573✔





2093



      QUERY_CHECK_CODE(code, lino, _end);




26,630,573✔





2094



      break;




26,629,950✔





2095



    }










2096



    case DYN_TYPE_VSTB_BATCH_SCAN:




13,382,958✔





2097



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




13,382,958✔





2098



      QUERY_CHECK_CODE(code, lino, _end);




13,384,864✔





2099



      break;




13,384,864✔





2100



    default:




×







2101



      code = TSDB_CODE_INVALID_PARA;




×







2102



      QUERY_CHECK_CODE(code, lino, _end);




×







2103



      break;




×







2104



  }










2105












2106



_end:




82,407,951✔





2107



  return code;




82,407,951✔





2108



}










2109












2110



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




1,022,485,669✔





2111



  int32_t         code = TSDB_CODE_SUCCESS;




1,022,485,669✔





2112



  int32_t         lino = 0;




1,022,485,669✔





2113



  STableScanInfo* pInfo = pOperator->info;




1,022,485,669✔





2114



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




1,022,834,313✔





2115



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




1,022,620,219✔





2116



  QRY_PARAM_CHECK(ppRes);




1,022,862,843✔





2117



  qTrace("%s call", __FUNCTION__);




1,022,794,979✔





2118












2119



  if (pOperator->pOperatorGetParam || pInfo->pBatchColMap) {




1,022,794,979✔





2120



    ETableScanDynType type = pOperator->pOperatorGetParam ?




81,990,452✔





2121



                                                          ((STableScanOperatorParam*)pOperator->pOperatorGetParam->value)->type :




82,405,063✔





2122



                                                          DYN_TYPE_VSTB_BATCH_SCAN;










2123












2124



    code = doDynamicTableScanNext(pOperator, type, ppRes);




82,404,947✔





2125



    QUERY_CHECK_CODE(code, lino, _end);




82,407,951✔





2126












2127



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




82,407,328✔





2128



      return code;




76,986,494✔





2129



    }










2130



  }










2131












2132



  // scan table one by one sequentially










2133



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




945,871,770✔





2134



    int32_t       numOfTables = 0;




5,840,933✔





2135



    STableKeyInfo tInfo = {0};




5,840,933✔





2136



    pInfo->countState = TABLE_COUNT_STATE_END;




5,840,933✔





2137












2138



    while (1) {




5,443,830✔





2139



      SSDataBlock* result = NULL;




11,284,763✔





2140



      code = doGroupedTableScan(pOperator, &result);




11,280,746✔





2141



      QUERY_CHECK_CODE(code, lino, _end);




11,277,061✔





2142












2143



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




11,277,061✔





2144



        (*ppRes) = result;




5,788,313✔





2145



        return code;




5,799,998✔





2146



      }










2147












2148



      // if no data, switch to next table and continue scan










2149



      pInfo->currentTable++;




5,488,162✔





2150












2151



      taosRLockLatch(&pTaskInfo->lock);




5,479,830✔





2152



      numOfTables = 0;




5,489,081✔





2153



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




5,489,081✔





2154



      if (code != TSDB_CODE_SUCCESS) {




5,485,066✔





2155



        taosRUnLockLatch(&pTaskInfo->lock);




×







2156



        TSDB_CHECK_CODE(code, lino, _end);




×







2157



      }










2158












2159



      if (pInfo->currentTable >= numOfTables) {




5,485,066✔





2160



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




40,318✔





2161



        taosRUnLockLatch(&pTaskInfo->lock);




40,318✔





2162



        (*ppRes) = NULL;




40,318✔





2163



        return code;




40,318✔





2164



      }










2165












2166



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




5,431,527✔





2167



      if (!tmp) {




5,439,544✔





2168



        taosRUnLockLatch(&pTaskInfo->lock);




×







2169



        (*ppRes) = NULL;




×







2170



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




×







2171



      }










2172












2173



      tInfo = *tmp;




5,439,544✔





2174



      taosRUnLockLatch(&pTaskInfo->lock);




5,435,845✔





2175












2176



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




5,448,123✔





2177



      QUERY_CHECK_CODE(code, lino, _end);




5,438,006✔





2178



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




5,438,006✔





2179



             pInfo->currentTable, numOfTables, GET_TASKID(pTaskInfo));










2180












2181



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




5,451,486✔





2182



      QUERY_CHECK_CODE(code, lino, _end);




5,437,964✔





2183



      pInfo->scanTimes = 0;




5,437,964✔





2184



    }










2185



  } else {  // scan table group by group sequentially










2186



    code = groupSeqTableScan(pOperator, ppRes);




939,496,504✔





2187



    QUERY_CHECK_CODE(code, lino, _end);




936,458,145✔





2188



  }










2189












2190



_end:




936,455,975✔





2191



  if (code != TSDB_CODE_SUCCESS) {




936,648,481✔





2192



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




2,793✔





2193



    pTaskInfo->code = code;




2,793✔





2194



    T_LONG_JMP(pTaskInfo->env, code);




2,793✔





2195



  }










2196












2197



  return code;




936,645,688✔





2198



}










2199












2200



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




14,882,379✔





2201



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




14,882,379✔





2202



  if (!pRecorder) {




14,806,876✔





2203



    return terrno;




×







2204



  }










2205



  STableScanInfo* pTableScanInfo = pOptr->info;




14,806,876✔





2206



  *pRecorder = pTableScanInfo->base.readRecorder;




14,847,046✔





2207



  *pOptrExplain = pRecorder;




14,855,924✔





2208



  *len = sizeof(SFileBlockLoadRecorder);




14,847,139✔





2209



  return 0;




14,854,854✔





2210



}










2211












2212



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




310,563,722✔





2213



  cleanupQueryTableDataCond(&pBase->cond);




310,563,722✔





2214



  cleanupQueryTableDataCond(&pBase->orgCond);




310,502,160✔





2215












2216



  if (pAPI->tsdReaderClose) {




310,590,715✔





2217



    pAPI->tsdReaderClose(pBase->dataReader);




310,618,951✔





2218



  }










2219



  pBase->dataReader = NULL;




310,366,771✔





2220












2221



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




310,391,861✔





2222



    taosArrayDestroy(pBase->matchInfo.pList);




310,378,383✔





2223



  }










2224












2225



  tableListDestroy(pBase->pTableListInfo);




310,389,221✔





2226



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




310,509,402✔





2227



  cleanupExprSupp(&pBase->pseudoSup);




310,497,703✔





2228



}




310,564,227✔





2229












2230



static void cleanReaderForVTable(STableScanInfo* pInfo){




5,050,075✔





2231



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




5,050,075✔





2232



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




5,051,724✔





2233



    while (pIter != NULL) {




5,073,445✔





2234



      void **reader = pIter;




22,212✔





2235



      if (*reader) {




22,212✔





2236



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




22,212✔





2237



          pInfo->base.dataReader = NULL;




19,954✔





2238



        }










2239



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




22,212✔





2240



      }










2241



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




22,212✔





2242



    }










2243



  }










2244



}




5,050,691✔





2245












2246



static void destroyTableScanOperatorInfo(void* param) {




281,940,969✔





2247



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




281,940,969✔





2248



  blockDataDestroy(pTableScanInfo->pResBlock);




281,940,969✔





2249



  blockDataDestroy(pTableScanInfo->pOrgBlock);




281,817,887✔





2250



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




281,827,938✔





2251



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




281,811,125✔





2252



    cleanReaderForVTable(pTableScanInfo);




5,048,394✔





2253



    taosHashCleanup(pTableScanInfo->readerCache);




5,051,233✔





2254



  }










2255



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




281,827,685✔





2256



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




281,845,740✔





2257



  taosMemoryFreeClear(param);




281,958,226✔





2258



}




281,743,015✔





2259












2260



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




281,691,462✔





2261



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




281,691,462✔





2262



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




13,067,990✔





2263



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




29,977,757✔





2264



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




16,934,920✔





2265



      if (pCol) {




16,917,375✔





2266



        pCol->info.noData = true;




16,917,541✔





2267



      }










2268



    }










2269



  }










2270



}




281,666,309✔





2271












2272



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




201,045✔





2273



  int32_t         code = TSDB_CODE_SUCCESS;




201,045✔





2274



  STableScanInfo*   pInfo = pOper->info;




201,045✔





2275



  pOper->status = OP_NOT_OPENED;




201,045✔





2276












2277



  pInfo->scanTimes = 0;




200,823✔





2278



  pInfo->currentGroupId = -1;




200,823✔





2279



  pInfo->tableEndIndex = -1;




200,823✔





2280



  pInfo->tableStartIndex = 0;




200,823✔





2281



  pInfo->currentTable = 0;




200,823✔





2282



  pInfo->scanMode = 0;




200,823✔





2283



  pInfo->countState = 0;




201,045✔





2284



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




201,045✔





2285












2286



  if (!pInfo->virtualStableScan) {




200,823✔





2287



  // if (pInfo->virtualStableScan && pInfo->readerCache) {










2288



  //   cleanReaderForVTable(pInfo);










2289



  //   taosHashClear(pInfo->readerCache);










2290



  //   pInfo->readerCache = false;










2291



  // } else {










2292



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




63,683✔





2293



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




63,905✔





2294



    }










2295



    pInfo->base.dataReader = NULL;




63,683✔





2296



  }










2297



  tableListDestroy(pInfo->base.pTableListInfo);




201,045✔





2298



  pInfo->base.pTableListInfo = tableListCreate();




200,823✔





2299



  if (!pInfo->base.pTableListInfo) {




201,045✔





2300



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







2301



    return terrno;




×







2302



  }










2303



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




201,045✔





2304












2305



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




201,045✔





2306



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




201,045✔





2307



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




124,964✔





2308



                                    &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










2309



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




124,964✔





2310



    if (code) {




62,699✔





2311



      qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







2312



      return code;




×







2313



    }










2314



  }










2315












2316



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




200,823✔





2317



  cleanupQueryTableDataCond(&pInfo->base.cond);




200,823✔





2318



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




201,045✔





2319



  if (code) {




201,045✔





2320



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







2321



    return code;




×







2322



  }










2323



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




201,045✔





2324



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




137,140✔





2325



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




137,140✔





2326



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




137,140✔





2327



  } 










2328












2329



  pOper->resultInfo.totalRows = 0;




201,045✔





2330



  blockDataEmpty(pInfo->pResBlock);




201,045✔





2331



  blockDataEmpty(pInfo->pOrgBlock);




200,823✔





2332



  taosHashClear(pInfo->pIgnoreTables);




201,045✔





2333



  taosArrayDestroy(pInfo->pBlockColMap);




200,823✔





2334



  pInfo->pBlockColMap = NULL;




200,823✔





2335



  return code;




201,045✔





2336



}










2337












2338



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




281,968,091✔





2339



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2340



                                    SOperatorInfo** pOptrInfo) {










2341



  QRY_PARAM_CHECK(pOptrInfo);




281,968,091✔





2342












2343



  int32_t         code = TSDB_CODE_SUCCESS;




281,955,924✔





2344



  int32_t         lino = 0;




281,955,924✔





2345



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




281,955,924✔





2346



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




281,717,933✔





2347



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




281,617,362✔






UNCOV

2348



    code = terrno;




×







2349



    goto _error;




×







2350



  }










2351












2352



  pOperator->pPhyNode = pTableScanNode;




281,627,273✔





2353



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




281,636,525✔





2354



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




281,645,972✔





2355












2356



  int32_t numOfCols = 0;




281,738,381✔





2357



  code =










2358



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




281,791,790✔





2359



  QUERY_CHECK_CODE(code, lino, _error);




281,774,402✔





2360












2361



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




281,774,402✔





2362



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




281,693,638✔





2363



  QUERY_CHECK_CODE(code, lino, _error);




281,565,386✔





2364












2365



  if (pScanNode->pScanPseudoCols != NULL) {




281,565,386✔





2366



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




50,849,505✔





2367



    pSup->pExprInfo = NULL;




50,849,646✔





2368



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




50,858,080✔





2369



    QUERY_CHECK_CODE(code, lino, _error);




50,845,899✔





2370












2371



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




50,845,899✔





2372



                                      &pTaskInfo->storageAPI.functionStore);










2373



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




50,855,029✔





2374



  }










2375












2376



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




281,506,434✔





2377



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




281,330,358✔





2378












2379



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




281,713,078✔





2380



  pInfo->base.readHandle = *readHandle;




281,129,760✔





2381



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




281,531,386✔





2382












2383



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




281,460,876✔





2384



  pInfo->sample.seed = taosGetTimestampSec();




281,891,448✔





2385












2386



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




281,571,020✔





2387



  initResultSizeInfo(&pOperator->resultInfo, 4096);




281,763,625✔





2388



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




281,615,492✔





2389



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




281,805,843✔





2390



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




281,326,891✔





2391












2392



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




281,411,591✔





2393



  QUERY_CHECK_CODE(code, lino, _error);




281,383,966✔





2394












2395



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




281,383,966✔





2396



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




281,418,617✔





2397



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




5,049,818✔





2398



    pInfo->pResBlock = NULL;




5,049,019✔





2399



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




5,050,742✔





2400



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




5,048,781✔





2401



  }










2402












2403



  if (pInfo->virtualStableScan) {




281,322,860✔





2404



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




5,048,220✔





2405



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




5,051,724✔





2406



  }










2407












2408



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




281,808,939✔





2409



                            pTaskInfo->pStreamRuntimeInfo);




281,653,682✔





2410



  QUERY_CHECK_CODE(code, lino, _error);




281,412,282✔





2411












2412



  pInfo->currentGroupId = -1;




281,389,612✔





2413












2414



  pInfo->tableEndIndex = -1;




281,562,204✔





2415



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




281,736,646✔





2416



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




281,489,284✔





2417












2418



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




281,809,563✔





2419



                  pTaskInfo);










2420



  pOperator->exprSupp.numOfExprs = numOfCols;




281,204,382✔





2421












2422



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




281,550,409✔





2423



  pInfo->ignoreTag = false;




281,785,237✔





2424












2425



  pInfo->lastBatchIdx = -1;




281,503,450✔





2426



  pInfo->currentBatchIdx = 0;




281,285,075✔





2427



  pInfo->base.pTableListInfo = pTableListInfo;




281,716,106✔





2428



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




281,566,373✔





2429



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







2430



    if (pInfo->base.metaCache.pTableMetaEntryCache == NULL) {




×







2431



      code = terrno;




×







2432



      QUERY_CHECK_CODE(code, lino, _error);




×







2433



    }










2434












2435



    taosLRUCacheSetStrictCapacity(pInfo->base.metaCache.pTableMetaEntryCache, false);




×







2436



  }










2437












2438



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




281,566,373✔





2439












2440



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanNext, NULL, destroyTableScanOperatorInfo,




281,758,093✔





2441



                                         optrDefaultBufFn, getTableScannerExecInfo, optrDefaultGetNextExtFn, NULL);










2442












2443



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




281,154,877✔





2444



  // for non-blocking operator, the open cost is always 0










2445



  pOperator->cost.openCost = 0;




281,272,457✔





2446



  *pOptrInfo = pOperator;




281,288,803✔





2447



  return TSDB_CODE_SUCCESS;




281,152,368✔





2448












2449



_error:




22,670✔





2450



  if (pInfo != NULL) {




22,670✔





2451



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




22,670✔





2452



    destroyTableScanOperatorInfo(pInfo);




22,670✔





2453



  }










2454












2455



  if (pOperator != NULL) {




22,670✔





2456



    pOperator->info = NULL;




22,670✔





2457



    destroyOperator(pOperator);




22,670✔





2458



  }










2459



  pTaskInfo->code = code;




22,670✔





2460



  return code;




22,670✔





2461



}










2462












2463



int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {




×







2464



  QRY_PARAM_CHECK(pOptrInfo);




×







2465












2466



  int32_t         code = 0;




×







2467



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




×







2468



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




×







2469



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




×







2470



    code = terrno;




×







2471



    goto _end;




×







2472



  }










2473












2474



  pInfo->base.dataReader = pReadHandle;




×







2475



  //  pInfo->prevGroupId       = -1;










2476












2477



  setOperatorInfo(pOperator, "TableSeqScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, false, OP_NOT_OPENED,




×







2478



                  pInfo, pTaskInfo);










2479



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImplNext, NULL, NULL, optrDefaultBufFn, NULL,




×







2480



                                         optrDefaultGetNextExtFn, NULL);










2481



  *pOptrInfo = pOperator;




×







2482



  return code;




×







2483












2484



_end:




×







2485



  if (pInfo != NULL) {




×







2486



    taosMemoryFree(pInfo);




×







2487



  }










2488












2489



  if (pOperator != NULL) {




×







2490



    taosMemoryFree(pOperator);




×







2491



  }










2492












2493



  pTaskInfo->code = code;




×







2494



  return code;




×







2495



}










2496












2497



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




13,584✔





2498



  int32_t code = TSDB_CODE_SUCCESS;




13,584✔





2499



  int32_t lino = 0;




13,584✔





2500



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




13,584✔





2501



    return code;




1,632✔





2502



  }










2503



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




11,952✔





2504



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




11,952✔





2505



  bool hasUnqualified = false;




11,952✔





2506












2507



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




11,952✔





2508



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




11,952✔





2509












2510



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




11,952✔





2511



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2512



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




11,952✔





2513



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2514












2515



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




11,952✔





2516



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




11,952✔





2517



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




42,976,080✔





2518



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




42,964,128✔





2519



    void*    data = colDataGetData(pColPk, i);




42,964,128✔





2520



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




42,966,432✔





2521



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




2,304✔





2522



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2523



      }










2524



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




2,304✔





2525



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




2,304✔





2526



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




2,304✔





2527



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




2,304✔





2528



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




2,304✔





2529



      taosMemoryFree(tmq);




2,304✔





2530



    } else {










2531



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




42,961,824✔





2532



    }










2533












2534



    if (!p[i]) {




42,964,128✔





2535



      hasUnqualified = true;




15,336,000✔





2536



    }










2537



  }










2538












2539



  if (hasUnqualified) {




11,952✔





2540



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




4,032✔





2541



    QUERY_CHECK_CODE(code, lino, _end);




4,032✔





2542



  }










2543












2544



_end:




11,952✔





2545



  taosMemoryFree(p);




11,952✔





2546



  if (code != TSDB_CODE_SUCCESS) {




11,952✔





2547



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




×







2548



  }










2549



  return code;




11,952✔





2550



}










2551












2552



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




1,365,384,106✔





2553



  int32_t p1 = *(int32_t*)param1;




1,365,384,106✔





2554



  int32_t p2 = *(int32_t*)param2;




1,365,396,891✔





2555












2556



  if (p1 == p2) {




1,365,404,497✔





2557



    return 0;




×







2558



  } else {










2559



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




1,365,404,497✔





2560



  }










2561



}










2562












2563



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




97,436,465✔





2564



  int32_t         code = TSDB_CODE_SUCCESS;




97,436,465✔





2565



  int32_t         lino = 0;




97,436,465✔





2566



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




97,436,465✔





2567



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




97,434,765✔





2568



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




97,435,445✔





2569



  const char*     id = GET_TASKID(pTaskInfo);




97,434,489✔





2570



  SArray* pColList = NULL;




97,435,516✔





2571












2572



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




97,435,516✔





2573



  QUERY_CHECK_CODE(code, lino, _end);




97,435,109✔





2574












2575



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




97,435,109✔





2576



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




97,434,429✔





2577



  pBlockInfo->type = STREAM_NORMAL;




97,434,769✔





2578



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




97,435,109✔





2579












2580



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




97,434,429✔





2581



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




97,435,109✔





2582












2583



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




97,436,129✔





2584



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




97,435,550✔





2585












2586



  // todo extract method










2587



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




520,308,975✔





2588



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




422,862,826✔





2589



    if (!pColMatchInfo->needOutput) {




422,850,812✔





2590



      continue;




638✔





2591



    }










2592












2593



    bool colExists = false;




422,855,979✔





2594



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




1,324,078,738✔





2595



      SColumnInfoData* pResCol = NULL;




1,323,550,630✔





2596



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




1,323,422,483✔





2597



      QUERY_CHECK_CODE(code, lino, _end);




1,323,634,095✔





2598












2599



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




1,323,634,095✔





2600



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




422,847,541✔





2601



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




422,872,522✔





2602



        QUERY_CHECK_CODE(code, lino, _end);




422,712,006✔





2603












2604



        colExists = true;




422,712,006✔





2605



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




422,712,006✔





2606



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




422,880,418✔





2607



        break;




422,880,418✔





2608



      }










2609



    }










2610












2611



    // the required column does not exists in submit block, let's set it to be all null value










2612



    if (!colExists) {




422,872,787✔





2613



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




×







2614



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




×







2615



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




×







2616



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




×







2617



    }










2618



  }










2619












2620



  // currently only the tbname pseudo column










2621



  if (pInfo->numOfPseudoExpr > 0) {




97,436,129✔





2622



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




122,614,795✔





2623



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




61,307,783✔





2624



    // ignore the table not exists error, since this table may have been dropped during the scan procedure.










2625



    if (code) {




61,302,431✔





2626



      QUERY_CHECK_CODE(code, lino, _end);




×







2627



    }










2628












2629



    // reset the error code.










2630



    terrno = 0;




61,302,431✔





2631












2632



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




251,638,462✔





2633



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




190,325,315✔





2634



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




190,332,971✔





2635



    }










2636



  }










2637












2638



  taosArraySort(pColList, colIdComparFn);




97,424,082✔





2639












2640



  int32_t i = 0, j = 0;




97,432,905✔





2641



  while (i < taosArrayGetSize(pColList)) {




710,480,384✔





2642



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




613,018,497✔





2643



    if (slot1 > j) {




613,047,479✔





2644



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




×







2645



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




×







2646



      j += 1;




×







2647



    } else {










2648



      i += 1;




613,047,479✔





2649



      j += 1;




613,047,479✔





2650



    }










2651



  }










2652












2653



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




97,435,440✔





2654



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




638✔





2655



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




638✔





2656



    j += 1;




638✔





2657



  }










2658












2659



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




97,433,751✔





2660



  QUERY_CHECK_CODE(code, lino, _end);




97,432,659✔





2661












2662



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




97,432,659✔





2663



  QUERY_CHECK_CODE(code, lino, _end);




97,430,449✔





2664












2665



_end:




97,430,449✔





2666



  taosArrayDestroy(pColList);




96,888,807✔





2667



  if (code != TSDB_CODE_SUCCESS) {




97,429,521✔





2668



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




×







2669



  }










2670



  return code;




97,420,631✔





2671



}










2672












2673



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




6,544,818✔





2674



  int32_t code = TSDB_CODE_SUCCESS;




6,544,818✔





2675



  int32_t lino = 0;




6,544,818✔





2676



  SValue  val = {0};




6,544,818✔





2677



  if (hasPrimaryKey) {




6,545,126✔





2678



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




13,584✔





2679



    if (code != TSDB_CODE_SUCCESS) {




13,584✔





2680



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




×







2681



      return code;




×







2682



    }










2683



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




13,584✔





2684












2685



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




13,584✔





2686



      return code;




3,744✔





2687



    }










2688



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




9,840✔





2689



    val.type = pColPk->info.type;




9,840✔





2690



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




9,840✔





2691



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




624✔





2692



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2693



      }










2694



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




624✔





2695



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




624✔





2696



      val.nData = varDataLen(tmp);




624✔





2697



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




624✔





2698



    } else {










2699



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




9,216✔





2700



    }










2701



  }










2702



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




6,541,382✔





2703












2704



_end:




6,539,848✔





2705



  if (code != TSDB_CODE_SUCCESS) {




6,539,848✔





2706



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




×







2707



  }










2708



  return code;




6,540,759✔





2709



}










2710












2711



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




122,050,617✔





2712



  int32_t        code = TSDB_CODE_SUCCESS;




122,050,617✔





2713



  int32_t        lino = 0;




122,050,617✔





2714



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




122,050,617✔





2715



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




122,059,756✔





2716












2717



  SStreamScanInfo* pInfo = pOperator->info;




122,062,107✔





2718



  const char*      id = GET_TASKID(pTaskInfo);




122,061,459✔





2719












2720



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




122,060,771✔





2721












2722



  if (isTaskKilled(pTaskInfo)) {




122,060,376✔





2723



    (*ppRes) = NULL;




×







2724



    return pTaskInfo->code;




×







2725



  }










2726












2727



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




122,062,724✔





2728



    while (1) {




3,744✔





2729



      SSDataBlock* pResult = NULL;




5,840,933✔





2730



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




5,840,933✔





2731



      QUERY_CHECK_CODE(code, lino, _end);




5,839,392✔





2732












2733



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




5,839,392✔





2734



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




5,799,383✔





2735



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




5,800,615✔





2736



        QUERY_CHECK_CODE(code, lino, _end);




5,797,841✔





2737



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




5,797,841✔





2738



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




5,799,691✔





2739



          (*ppRes) = pResult;




5,796,871✔





2740



          return code;




5,796,871✔





2741



        }










2742



      } else {










2743



        break;










2744



      }










2745



    }










2746












2747



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




40,318✔





2748



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




40,318✔





2749












2750



    pTSInfo->base.dataReader = NULL;




40,318✔





2751



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




40,318✔





2752



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




40,318✔





2753



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




40,318✔





2754



      (*ppRes) = NULL;




10,683✔





2755



      return code;




10,683✔





2756



    }










2757












2758



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




29,635✔





2759



  }










2760












2761



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




116,255,834✔





2762



    while (1) {




757,710✔





2763



      bool hasResult =










2764



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




117,013,884✔





2765












2766



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




116,995,476✔





2767



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




117,004,300✔





2768












2769



      // curVersion move to next










2770



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




117,005,537✔





2771












2772



      // use ts to pass time when replay, because ts not used if type is log










2773



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




117,001,839✔





2774












2775



      if (hasResult) {




117,003,857✔





2776



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




97,426,442✔





2777



               pTaskInfo->streamInfo.currentOffset.version);










2778



        blockDataCleanup(pInfo->pRes);




97,436,057✔





2779



        code = setBlockIntoRes(pInfo, pRes);




97,431,371✔





2780



        QUERY_CHECK_CODE(code, lino, _end);




97,420,606✔





2781



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




97,420,606✔





2782



               pTaskInfo->streamInfo.currentOffset.version);










2783



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




97,426,192✔





2784



          (*ppRes) = pInfo->pRes;




96,679,099✔





2785



          return code;




96,677,399✔





2786



        }










2787



      } else {










2788



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




19,577,415✔





2789



        (*ppRes) = NULL;




19,577,685✔





2790



        return code;




19,577,415✔





2791



      }










2792



    }










2793



  } else {










2794



    qError("unexpected streamInfo prepare type: %d", pTaskInfo->streamInfo.currentOffset.type);




×







2795



    (*ppRes) = NULL;




×







2796



    return code;




×







2797



  }










2798












2799



_end:




×







2800



  if (code != TSDB_CODE_SUCCESS) {




×







2801



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




×







2802



    pTaskInfo->code = code;




×







2803



    T_LONG_JMP(pTaskInfo->env, code);




×







2804



  }










2805



  (*ppRes) = NULL;




×







2806



  return code;




×







2807



}










2808












2809



static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {




×







2810



  SSDataBlock* pRes = NULL;




×







2811



  int32_t      code = doQueueScanNext(pOperator, &pRes);




×







2812



  return pRes;




×







2813



}










2814












2815



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




317,336✔





2816



  int32_t code = TSDB_CODE_SUCCESS;




317,336✔





2817



  int32_t lino = 0;




317,336✔





2818



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




317,336✔





2819



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




320,426✔





2820












2821



  // Transfer the Array of STableKeyInfo into uid list.










2822



  int32_t size = 0;




320,426✔





2823



  code = tableListGetSize(pTableListInfo, &size);




320,426✔





2824



  QUERY_CHECK_CODE(code, lino, _end);




320,731✔





2825



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




9,561,880✔





2826



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,239,566✔





2827



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




9,200,769✔





2828



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




9,200,769✔





2829



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




9,241,149✔





2830



  }










2831












2832



  (*ppArrayRes) = tableIdList;




322,314✔





2833












2834



_end:




320,403✔





2835



  if (code != TSDB_CODE_SUCCESS) {




320,731✔





2836



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




×







2837



  }










2838



  return code;




320,731✔





2839



}










2840












2841



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




1,507,605✔





2842



  int32_t        code = TSDB_CODE_SUCCESS;




1,507,605✔





2843



  int32_t        lino = 0;




1,507,605✔





2844



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,507,605✔





2845



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,507,605✔





2846












2847



  SStreamRawScanInfo* pInfo = pOperator->info;




1,507,605✔





2848



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




1,507,605✔





2849



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,507,605✔





2850












2851



  qDebug("tmqsnap doRawScan called");




1,507,605✔





2852



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




1,507,605✔





2853



    bool hasNext = false;




1,502,829✔





2854



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




1,502,829✔





2855



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




1,501,989✔





2856



      if (code != TSDB_CODE_SUCCESS) {




1,499,882✔





2857



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




×







2858



        QUERY_CHECK_CODE(code, lino, _end);




×







2859



      }










2860



    }










2861












2862



    if (pInfo->dataReader && hasNext) {




1,500,722✔





2863



      if (isTaskKilled(pTaskInfo)) {




747,557✔





2864



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




×







2865



        return code;




×







2866



      }










2867












2868



      SSDataBlock* pBlock = NULL;




747,557✔





2869



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




746,654✔





2870



      QUERY_CHECK_CODE(code, lino, _end);




746,955✔





2871












2872



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




746,955✔





2873



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




746,955✔





2874



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




746,955✔





2875



        QUERY_CHECK_CODE(code, lino, _end);




746,052✔





2876



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




746,052✔





2877



        (*ppRes) = pBlock;




747,858✔





2878



        return code;




747,557✔





2879



      }










2880



    }










2881












2882



    SMetaTableInfo mtInfo = {0};




753,466✔





2883



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




755,272✔





2884



    QUERY_CHECK_CODE(code, lino, _end);




754,028✔





2885



    if (code != 0) {




754,028✔





2886



      destroyMetaTableInfo(&mtInfo);










2887



      QUERY_CHECK_CODE(code, lino, _end);




×







2888



    }










2889



    STqOffsetVal offset = {0};




754,028✔





2890



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




754,634✔





2891



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




10,610✔





2892



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




10,610✔





2893



    } else {










2894



      SValue val = {0};




745,268✔





2895



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




745,268✔





2896



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




744,967✔





2897



    }










2898



    destroyMetaTableInfo(&mtInfo);










2899



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




755,272✔





2900



    QUERY_CHECK_CODE(code, lino, _end);




755,272✔





2901



    (*ppRes) = NULL;




755,272✔





2902



    return code;




755,272✔





2903



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




4,776✔





2904



    SSnapContext* sContext = pInfo->sContext;




4,776✔





2905



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




39,840✔





2906



      void*   data = NULL;




39,840✔





2907



      int32_t dataLen = 0;




39,840✔





2908



      int16_t type = 0;




39,840✔





2909



      int64_t uid = 0;




39,840✔





2910



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




39,840✔





2911



        qError("tmqsnap getTableInfoFromSnapshot error");




×







2912



        taosMemoryFreeClear(data);




×







2913



        break;




×







2914



      }










2915












2916



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




39,840✔





2917



        STqOffsetVal offset = {0};




4,776✔





2918



        SValue       val = {0};




4,776✔





2919



        tqOffsetResetToData(&offset, 0, INT64_MIN, val);




×







2920



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




4,776✔





2921



        QUERY_CHECK_CODE(code, lino, _end);




4,776✔





2922



        break;




4,776✔





2923



      } else {










2924



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




35,064✔





2925



        SMqMetaRsp tmpMetaRsp = {0};




35,064✔





2926



        tmpMetaRsp.resMsgType = type;




35,064✔





2927



        tmpMetaRsp.metaRspLen = dataLen;




35,064✔





2928



        tmpMetaRsp.metaRsp = data;




35,064✔





2929



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




35,064✔





2930



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




4,248✔





2931



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




4,248✔





2932












2933



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




4,248✔





2934



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




4,248✔





2935



        }










2936



        int32_t  tempRes = TSDB_CODE_SUCCESS;




35,064✔





2937



        uint32_t len = 0;




35,064✔





2938



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




35,064✔





2939



        if (TSDB_CODE_SUCCESS != tempRes) {




35,064✔





2940



          qError("tmqsnap tEncodeMqMetaRsp error");




×







2941



          taosMemoryFreeClear(data);




×







2942



          break;




×







2943



        }










2944












2945



        int32_t tLen = sizeof(SMqRspHead) + len;




35,064✔





2946



        void*   tBuf = taosMemoryCalloc(1, tLen);




35,064✔





2947



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




35,064✔





2948












2949



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




35,064✔





2950



        SEncoder encoder = {0};




35,064✔





2951



        tEncoderInit(&encoder, metaBuff, len);




35,064✔





2952



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




35,064✔





2953



        if (tempLen < 0) {




35,064✔





2954



          qError("tmqsnap tEncodeMqMetaRsp error");




×







2955



          tEncoderClear(&encoder);




×







2956



          taosMemoryFreeClear(tBuf);




×







2957



          taosMemoryFreeClear(data);




×







2958



          break;




×







2959



        }










2960



        taosMemoryFreeClear(data);




35,064✔





2961



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




35,064✔





2962



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




35,064✔





2963












2964



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




35,064✔





2965



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




35,064✔





2966



      }










2967



    }










2968












2969



    (*ppRes) = NULL;




4,776✔





2970



    return code;




4,776✔





2971



  }










2972












2973



_end:




×







2974



  if (code != TSDB_CODE_SUCCESS) {




×







2975



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




×







2976



    pTaskInfo->code = code;




×







2977



    T_LONG_JMP(pTaskInfo->env, code);




×







2978



  }










2979












2980



  (*ppRes) = NULL;




×







2981



  return code;




×







2982



}










2983












2984



static void destroyTmqRawScanOperatorInfo(void* param) {




115,593✔





2985



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




115,593✔





2986



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




115,593✔





2987



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




115,593✔





2988



  tableListDestroy(pRawScan->pTableListInfo);




115,593✔





2989



  taosMemoryFree(pRawScan);




115,593✔





2990



}




115,593✔





2991












2992



// for subscribing db or stb (not including column),










2993



// if this scan is used, meta data can be return










2994



// and schemas are decided when scanning










2995



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




115,288✔





2996



  // create operator










2997



  // create tb reader










2998



  // create meta reader










2999



  // create tq reader










3000












3001



  QRY_PARAM_CHECK(pOptrInfo);




115,288✔





3002



  int32_t code = TSDB_CODE_SUCCESS;




115,593✔





3003



  int32_t lino = 0;




115,593✔





3004












3005



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




115,593✔





3006



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




115,593✔





3007



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




115,593✔





3008



    code = terrno;




×







3009



    lino = __LINE__;




×







3010



    goto _end;




×







3011



  }










3012












3013



  pInfo->pTableListInfo = tableListCreate();




115,593✔





3014



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




115,593✔





3015



  pInfo->vnode = pHandle->vnode;




115,593✔





3016



  pInfo->pAPI = &pTaskInfo->storageAPI;




115,593✔





3017












3018



  pInfo->sContext = pHandle->sContext;




115,593✔





3019



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




115,593✔





3020



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




115,593✔





3021



                  pTaskInfo);










3022












3023



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




115,593✔





3024



                                         NULL, optrDefaultGetNextExtFn, NULL);










3025



  *pOptrInfo = pOperator;




115,593✔





3026



  return code;




115,593✔





3027












3028



_end:




×







3029



  if (code != TSDB_CODE_SUCCESS) {




×







3030



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




×







3031



  }










3032



  taosMemoryFree(pInfo);




×







3033



  taosMemoryFree(pOperator);




×







3034



  pTaskInfo->code = code;




×







3035



  return code;




×







3036



}










3037












3038



void destroyTmqScanOperatorInfo(void* param) {




320,731✔





3039



  if (param == NULL) {




320,731✔





3040



    return;




×







3041



  }










3042












3043



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




320,731✔





3044



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




320,731✔





3045



    destroyOperator(pStreamScan->pTableScanOp);




320,731✔





3046



  }










3047












3048



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




320,731✔





3049



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




320,731✔





3050



  }










3051



  if (pStreamScan->pVtableMergeHandles) {




320,731✔





3052



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3053



    pStreamScan->pVtableMergeHandles = NULL;




×







3054



  }










3055



  if (pStreamScan->pVtableMergeBuf) {




320,731✔





3056



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3057



    pStreamScan->pVtableMergeBuf = NULL;




×







3058



  }










3059



  if (pStreamScan->pVtableReadyHandles) {




320,731✔





3060



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3061



    pStreamScan->pVtableReadyHandles = NULL;




×







3062



  }










3063



  if (pStreamScan->pTableListInfo) {




320,731✔





3064



    tableListDestroy(pStreamScan->pTableListInfo);




×







3065



    pStreamScan->pTableListInfo = NULL;




×







3066



  }










3067



  if (pStreamScan->matchInfo.pList) {




320,731✔





3068



    taosArrayDestroy(pStreamScan->matchInfo.pList);




320,731✔





3069



  }










3070



  if (pStreamScan->pPseudoExpr) {




320,478✔





3071



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




185,205✔





3072



    taosMemoryFree(pStreamScan->pPseudoExpr);




185,205✔





3073



  }










3074












3075



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




320,731✔





3076



  cleanupExprSupp(&pStreamScan->tagCalSup);




320,731✔





3077












3078



  blockDataDestroy(pStreamScan->pRes);




320,731✔





3079



  blockDataDestroy(pStreamScan->pUpdateRes);




320,731✔





3080



  blockDataDestroy(pStreamScan->pDeleteDataRes);




320,731✔





3081



  blockDataDestroy(pStreamScan->pUpdateDataRes);




320,731✔





3082



  blockDataDestroy(pStreamScan->pCreateTbRes);




320,731✔





3083



  taosArrayDestroy(pStreamScan->pBlockLists);




320,462✔





3084



  blockDataDestroy(pStreamScan->pCheckpointRes);




320,462✔





3085












3086



  taosMemoryFree(pStreamScan);




320,731✔





3087



}










3088












3089



int32_t addPrimaryKeyCol(SSDataBlock* pBlock, uint8_t type, int32_t bytes) {




×







3090



  int32_t code = TSDB_CODE_SUCCESS;




×







3091



  int32_t lino = 0;




×







3092



  pBlock->info.rowSize += bytes;




×







3093



  SColumnInfoData infoData = {0};




×







3094



  infoData.info.type = type;




×







3095



  infoData.info.bytes = bytes;




×







3096



  void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData);




×







3097



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




×







3098












3099



_end:




×







3100



  if (code != TSDB_CODE_SUCCESS) {




×







3101



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




×







3102



  }










3103



  return code;




×







3104



}










3105












3106



 int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




320,112✔





3107



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3108



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3109



  QRY_PARAM_CHECK(pOptrInfo);




320,112✔





3110












3111



  int32_t          code = TSDB_CODE_SUCCESS;




320,382✔





3112



  int32_t          lino = 0;




320,382✔





3113



  SArray*          pColIds = NULL;




320,382✔





3114



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




320,382✔





3115



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




320,731✔





3116



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




320,731✔





3117



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




320,731✔





3118












3119



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




320,731✔





3120



    code = terrno;




×







3121



    goto _error;




×







3122



  }










3123












3124



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




320,731✔





3125



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




320,731✔





3126












3127



  pInfo->pTagCond = pTagCond;




320,731✔





3128



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




320,731✔





3129












3130



  int32_t numOfCols = 0;




320,731✔





3131



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




320,731✔





3132



  if (code != TSDB_CODE_SUCCESS) {




320,423✔





3133



    goto _error;




×







3134



  }










3135












3136



  SDataType pkType = {0};




320,423✔





3137



  pInfo->primaryKeyIndex = -1;




320,423✔





3138



  pInfo->basic.primaryPkIndex = -1;




320,423✔





3139



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




320,423✔





3140



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




320,423✔





3141



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




320,731✔





3142












3143



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




2,015,792✔





3144



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




1,694,753✔





3145



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




1,695,020✔





3146












3147



    int16_t colId = id->colId;




1,695,020✔





3148



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




1,695,369✔





3149



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




1,695,369✔





3150












3151



    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,695,369✔





3152



      pInfo->primaryTsIndex = id->dstSlotId;




320,731✔





3153



    }










3154



    if (id->isPk) {




1,694,753✔





3155



      pInfo->primaryKeyIndex = id->dstSlotId;




1,488✔





3156



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




1,488✔





3157



      pkType = id->dataType;




1,488✔





3158



    }










3159



  }










3160












3161



  pInfo->pPartTbnameSup = NULL;




321,039✔





3162



  if (pTableScanNode->pSubtable != NULL) {




320,423✔





3163



    SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));




×







3164



    if (pSubTableExpr == NULL) {




×







3165



      code = terrno;




×







3166



      goto _error;




×







3167



    }










3168












3169



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3170



    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);




×







3171



    QUERY_CHECK_CODE(code, lino, _error);




×







3172












3173



    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {




×







3174



      goto _error;




×







3175



    }










3176



  }










3177












3178



  if (pTableScanNode->pTags != NULL) {




320,731✔





3179



    int32_t    numOfTags;




×







3180



    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);




×







3181



    if (pTagExpr == NULL) {




×







3182



      goto _error;




×







3183



    }










3184



    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);




×







3185



    if (code != 0) {




×







3186



      goto _error;




×







3187



    }










3188



  }










3189












3190



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




320,423✔





3191



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




320,423✔





3192












3193



  if (pHandle->vnode) {




320,423✔





3194



    SOperatorInfo* pTableScanOp = NULL;




320,423✔





3195



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




320,423✔





3196



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




320,086✔






UNCOV

3197



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




×







3198



      goto _error;




×







3199



    }










3200












3201



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




320,391✔





3202



    if (pHandle->version > 0) {




320,391✔





3203



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




320,391✔





3204



    }










3205












3206



    STableKeyInfo* pList = NULL;




320,424✔





3207



    int32_t        num = 0;




320,114✔





3208



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




319,744✔





3209



    QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3210












3211



    if (pHandle->initTableReader) {




320,731✔





3212



      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




320,731✔





3213



      pTSInfo->base.dataReader = NULL;




320,731✔





3214



    }










3215












3216



    if (pHandle->initTqReader) {




320,391✔





3217



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




319,828✔





3218



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




320,731✔





3219



    } else {










3220



      pInfo->tqReader = pHandle->tqReader;




563✔





3221



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




×







3222



    }










3223












3224



    pInfo->pUpdateInfo = NULL;




320,421✔





3225



    pInfo->pTableScanOp = pTableScanOp;




320,421✔





3226



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




320,421✔





3227



      pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1,




×







3228



                                            pInfo->primaryTsIndex);










3229



    }










3230












3231



    pInfo->readHandle = *pHandle;




320,731✔





3232



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




320,426✔





3233



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




320,116✔





3234



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




320,113✔





3235



    pInfo->hasPart = false;




320,731✔





3236












3237



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




320,113✔





3238



    QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3239












3240



    // set the extract column id to streamHandle










3241



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




320,731✔





3242



    QUERY_CHECK_CODE(code, lino, _error);




319,756✔





3243












3244



    SArray* tableIdList = NULL;




319,756✔





3245



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




320,084✔





3246



    QUERY_CHECK_CODE(code, lino, _error);




320,403✔





3247



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




320,403✔





3248



    QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3249



    taosArrayDestroy(tableIdList);




320,731✔





3250



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




320,731✔





3251



  } else {










3252



    taosArrayDestroy(pColIds);




×







3253



    tableListDestroy(pTableListInfo);




×







3254



  }










3255












3256



  // clear the local variable to avoid repeatly free










3257



  pColIds = NULL;




320,731✔





3258












3259



  // create the pseduo columns info










3260



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




320,731✔





3261



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




185,205✔





3262



    QUERY_CHECK_CODE(code, lino, _error);




185,205✔





3263



  }










3264












3265



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




320,731✔





3266



  QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3267












3268



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




320,731✔





3269



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




320,731✔





3270



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




320,403✔





3271



  QUERY_CHECK_CODE(code, lino, _error);




320,403✔





3272












3273



  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;




320,403✔





3274



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




320,403✔





3275



  pInfo->groupId = 0;




320,731✔





3276



  pInfo->igCheckGroupId = false;




320,438✔





3277



  pInfo->pStreamScanOp = pOperator;




320,403✔





3278



  pInfo->deleteDataIndex = 0;




320,731✔





3279



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




320,110✔





3280



  QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3281












3282



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




320,731✔





3283



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




320,403✔





3284



  QUERY_CHECK_CODE(code, lino, _error);




320,134✔





3285












3286



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




320,134✔





3287



  pInfo->partitionSup.needCalc = false;




320,462✔





3288



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




320,462✔





3289



  pInfo->igExpired = pTableScanNode->igExpired;




320,462✔





3290



  pInfo->twAggSup.maxTs = INT64_MIN;




320,134✔





3291



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




320,134✔





3292



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




320,462✔





3293



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




320,134✔





3294



  pInfo->pFillSup = NULL;




320,731✔





3295



  pInfo->useGetResultRange = false;




320,403✔





3296



  pInfo->pRangeScanRes = NULL;




319,266✔





3297












3298



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




320,731✔





3299



  QUERY_CHECK_CODE(code, lino, _error);




320,731✔





3300












3301



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




320,731✔





3302



                  pTaskInfo);










3303



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




320,403✔





3304












3305



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




320,731✔





3306



                                         NULL, optrDefaultGetNextExtFn, NULL);










3307












3308



  *pOptrInfo = pOperator;




320,403✔





3309



  return code;




320,096✔





3310












3311



_error:




×







3312



  if (pColIds != NULL) {




×







3313



    taosArrayDestroy(pColIds);




×







3314



  }










3315












3316



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×







3317



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×







3318



    if (p != NULL) {




×







3319



      p->base.pTableListInfo = NULL;




×







3320



    }










3321



    destroyTmqScanOperatorInfo(pInfo);




×







3322



  }










3323












3324



  if (pOperator != NULL) {




×







3325



    pOperator->info = NULL;




×







3326



    destroyOperator(pOperator);




×







3327



  }










3328



  pTaskInfo->code = code;




×







3329



  return code;




×







3330



}










3331












3332



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




12,034,424✔





3333



  int32_t        code = TSDB_CODE_SUCCESS;




12,034,424✔





3334



  int32_t        lino = 0;




12,034,424✔





3335



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




12,034,424✔





3336



  STagScanInfo*  pInfo = pOperator->info;




12,035,410✔





3337



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




12,033,808✔





3338



  int32_t        count = pRes->info.rows;




12,035,281✔





3339












3340



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




12,033,313✔





3341



  if (!item) {




12,032,393✔





3342



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3343



           GET_TASKID(pTaskInfo));










3344



    tDecoderClear(&(*mr).coder);




×







3345



    goto _end;




×







3346



  }










3347












3348



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




12,032,393✔





3349



  tDecoderClear(&(*mr).coder);




12,035,410✔





3350



  if (code != TSDB_CODE_SUCCESS) {




12,035,406✔





3351



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3352



           GET_TASKID(pTaskInfo));










3353



    goto _end;




×







3354



  }










3355












3356



  char str[512];




12,035,302✔





3357



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




43,655,391✔





3358



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




31,621,501✔





3359












3360



    // refactor later










3361



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




31,622,791✔





3362



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




3,667,811✔





3363



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




3,667,324✔





3364



      QUERY_CHECK_CODE(code, lino, _end);




3,667,776✔





3365



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




27,955,409✔





3366



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




5,098,915✔





3367



      QUERY_CHECK_CODE(code, lino, _end);




5,099,098✔





3368



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




22,856,494✔





3369



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




14,924✔





3370



      QUERY_CHECK_CODE(code, lino, _end);




14,924✔





3371



    } else {  // it is a tag value










3372



      STagVal val = {0};




22,841,387✔





3373



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




22,841,387✔





3374



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




22,842,061✔





3375












3376



      char* data = NULL;




22,841,079✔





3377



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




22,841,079✔





3378



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




22,839,232✔





3379



      } else {










3380



        data = (char*)p;




1,356✔





3381



      }










3382












3383



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




22,841,878✔





3384



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




22,842,186✔





3385



      QUERY_CHECK_CODE(code, lino, _end);




22,841,878✔





3386












3387



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




22,841,878✔





3388



          (data != NULL)) {










3389



        taosMemoryFree(data);




8,061,244✔





3390



      }










3391



    }










3392



  }










3393












3394



_end:




12,036,844✔





3395



  if (code != TSDB_CODE_SUCCESS) {




12,033,894✔





3396



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




×







3397



    pTaskInfo->code = code;




×







3398



  } else {










3399



    pRes->info.rows++;




12,033,894✔





3400



  }










3401












3402



  return code;




12,035,367✔





3403



}










3404












3405



static void tagScanFreeUidTag(void* p) {




8,585,210✔





3406



  STUidTagInfo* pInfo = p;




8,585,210✔





3407



  if (pInfo->pTagVal != NULL) {




8,585,210✔





3408



    taosMemoryFree(pInfo->pTagVal);




8,586,748✔





3409



  }










3410



}




8,583,970✔





3411












3412



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




1,596,044✔





3413



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




1,596,044✔





3414



  if (pColumnData == NULL) {




1,595,538✔





3415



    return terrno;




×







3416



  }










3417












3418



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




1,595,538✔





3419



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




1,594,425✔





3420



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




1,595,399✔





3421



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




1,593,139✔





3422












3423



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




1,594,931✔





3424



  if (code != TSDB_CODE_SUCCESS) {




1,594,106✔





3425



    terrno = code;




×







3426



    taosMemoryFree(pColumnData);




×







3427



    return terrno;




×







3428



  }










3429












3430



  pParam->columnData = pColumnData;




1,594,106✔





3431



  pParam->colAlloced = true;




1,595,225✔





3432



  return TSDB_CODE_SUCCESS;




1,595,568✔





3433



}










3434












3435



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




9,881,150✔





3436



  int32_t                code = TSDB_CODE_SUCCESS;




9,881,150✔





3437



  int32_t                lino = 0;




9,881,150✔





3438



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




9,881,150✔





3439



  SColumnNode*           pSColumnNode = NULL;




9,881,150✔





3440



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




9,882,522✔





3441



    pSColumnNode = *(SColumnNode**)pNode;




2,783,589✔





3442



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




7,110,945✔





3443



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




492✔





3444



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




492✔





3445



      pSColumnNode = NULL;




×







3446



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3447



      if (NULL == pSColumnNode) {




×







3448



        return DEAL_RES_ERROR;




×







3449



      }










3450



      pSColumnNode->colId = -1;




×







3451



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3452



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3453



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3454



      nodesDestroyNode(*pNode);




×







3455



      *pNode = (SNode*)pSColumnNode;




×







3456



    } else {










3457



      return DEAL_RES_CONTINUE;




492✔





3458



    }










3459



  } else {










3460



    return DEAL_RES_CONTINUE;




7,103,998✔





3461



  }










3462












3463



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




2,783,246✔





3464



  if (!data) {




2,781,923✔





3465



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




1,597,571✔





3466



    if (code == TSDB_CODE_DUP_KEY) {




1,600,693✔





3467



      code = TSDB_CODE_SUCCESS;




×







3468



    }










3469



    QUERY_CHECK_CODE(code, lino, _end);




1,600,693✔





3470



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




1,600,693✔





3471



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




1,598,889✔





3472



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




1,599,237✔





3473



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




1,596,522✔





3474



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




1,597,914✔





3475



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




1,599,376✔





3476



  } else {










3477



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




1,184,352✔





3478



    pSColumnNode->slotId = col->slotId;




1,184,352✔





3479



  }










3480












3481



_end:




2,781,432✔





3482



  if (code != TSDB_CODE_SUCCESS) {




2,780,454✔





3483



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




146✔





3484



    return DEAL_RES_ERROR;




×







3485



  }










3486



  return DEAL_RES_CONTINUE;




2,780,308✔





3487



}










3488












3489



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




1,597,354✔





3490



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3491



  int32_t code = TSDB_CODE_SUCCESS;




1,597,354✔





3492



  int32_t lino = 0;




1,597,354✔





3493



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,597,354✔





3494



  SArray* pBlockList = NULL;




1,597,354✔





3495












3496



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




1,597,354✔





3497



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




1,594,721✔





3498












3499



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,594,721✔





3500



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




1,596,044✔





3501












3502



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




1,596,402✔





3503



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




1,596,402✔





3504












3505



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




1,596,402✔





3506












3507



  SScalarParam output = {0};




1,596,044✔





3508



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




1,595,064✔





3509



  QUERY_CHECK_CODE(code, lino, _end);




1,595,568✔





3510












3511



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,595,568✔





3512



  gTaskScalarExtra.pStreamRange = NULL;




1,595,568✔





3513



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




1,595,553✔





3514



  QUERY_CHECK_CODE(code, lino, _end);




1,593,048✔





3515












3516



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




1,593,048✔





3517



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




3,984,034✔





3518



    if (result[i]) {




2,389,718✔





3519



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




2,266,414✔





3520



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




2,266,414✔





3521



    }










3522



  }










3523












3524



  colDataDestroy(output.columnData);




1,596,528✔





3525



  taosMemoryFreeClear(output.columnData);




1,592,564✔





3526












3527



_end:




1,592,372✔





3528



  blockDataDestroy(pResBlock);




1,592,372✔





3529



  taosArrayDestroy(pBlockList);




1,590,567✔





3530



  if (code != TSDB_CODE_SUCCESS) {




1,589,923✔





3531



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




×







3532



  }










3533



  return code;




1,589,923✔





3534



}










3535












3536



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




29,181,808✔





3537



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3538



                                         const SStorageAPI* pAPI, void* pVnode) {










3539



  int32_t code = TSDB_CODE_SUCCESS;




29,181,808✔





3540



  int32_t lino = 0;




29,181,808✔





3541



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




29,181,808✔





3542



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




13,819,197✔





3543



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




×







3544



      STR_TO_VARSTR(str, "ctbidx");




×







3545












3546



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




×







3547



      QUERY_CHECK_CODE(code, lino, _end);




×







3548



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




13,812,846✔





3549



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




6,905,309✔





3550



      QUERY_CHECK_CODE(code, lino, _end);




6,909,890✔





3551



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




6,911,052✔





3552



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




6,909,128✔





3553



      QUERY_CHECK_CODE(code, lino, _end);




6,909,370✔





3554



    }










3555



  } else {










3556



    STagVal tagVal = {0};




15,358,832✔





3557



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




15,359,810✔





3558



    if (pUidTagInfo->pTagVal == NULL) {




15,359,819✔





3559



      colDataSetNULL(pColInfo, rowIndex);




×







3560



    } else {










3561



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




15,357,826✔





3562












3563



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




15,365,799✔





3564



        colDataSetNULL(pColInfo, rowIndex);




7,930✔





3565



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




15,358,556✔





3566



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




×







3567



        QUERY_CHECK_CODE(code, lino, _end);




×







3568



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




19,190,746✔





3569



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




3,831,608✔





3570



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3571



        }










3572



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




3,838,013✔





3573



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




3,835,255✔





3574












3575



        varDataSetLen(tmp, tagVal.nData);




3,835,255✔





3576



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




3,833,291✔





3577



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




3,840,640✔





3578



        taosMemoryFree(tmp);




3,840,164✔





3579



        QUERY_CHECK_CODE(code, lino, _end);




3,838,393✔





3580



      } else {










3581



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




11,511,498✔





3582



        QUERY_CHECK_CODE(code, lino, _end);




11,510,792✔





3583



      }










3584



    }










3585



  }










3586












3587



_end:




29,176,840✔





3588



  if (code != TSDB_CODE_SUCCESS) {




29,176,840✔





3589



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




×







3590



  }










3591



  return code;




29,169,612✔





3592



}










3593












3594



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




5,526,551✔





3595



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3596



  int32_t       code = TSDB_CODE_SUCCESS;




5,526,551✔





3597



  int32_t       lino = 0;




5,526,551✔





3598



  STagScanInfo* pInfo = pOperator->info;




5,526,551✔





3599



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




5,528,002✔





3600



  if (!ignoreFilterIdx) {




5,528,641✔





3601



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,594,021✔





3602



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




3,860,055✔





3603



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




2,263,292✔





3604



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,264,257✔





3605



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




2,261,836✔





3606



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




12,946,484✔





3607



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




10,678,277✔





3608



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




10,685,645✔





3609



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




10,685,645✔





3610



        QUERY_CHECK_CODE(code, lino, _end);




10,684,648✔





3611



      }










3612



    }










3613



  } else {










3614



    size_t szTables = taosArrayGetSize(aUidTags);




3,934,620✔





3615



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




10,130,808✔





3616



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




6,195,930✔





3617



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




6,196,545✔





3618



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




24,680,210✔





3619



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




18,487,837✔





3620



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




18,487,867✔





3621



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




18,487,867✔





3622



        QUERY_CHECK_CODE(code, lino, _end);




18,483,665✔





3623



      }










3624



    }










3625



  }










3626












3627



_end:




3,934,878✔





3628



  if (code != TSDB_CODE_SUCCESS) {




5,531,641✔





3629



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




×







3630



  }










3631



  return code;




5,529,099✔





3632



}










3633












3634



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




10,622,355✔





3635



  int32_t        code = TSDB_CODE_SUCCESS;




10,622,355✔





3636



  int32_t        lino = 0;




10,622,355✔





3637



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




10,622,355✔





3638



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




10,628,536✔





3639












3640



  STagScanInfo* pInfo = pOperator->info;




10,604,436✔





3641



  SSDataBlock*  pRes = pInfo->pRes;




10,614,466✔





3642












3643



  QRY_PARAM_CHECK(ppRes);




10,620,985✔





3644












3645



  if (pOperator->status == OP_EXEC_DONE) {




10,623,800✔





3646



    return TSDB_CODE_SUCCESS;




5,029,318✔





3647



  }










3648



  blockDataCleanup(pRes);




5,585,983✔





3649












3650



  if (pInfo->pCtbCursor == NULL) {




5,598,953✔





3651



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




5,594,519✔





3652



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




5,597,087✔





3653



  } else {










3654



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3655



    QUERY_CHECK_CODE(code, lino, _end);




×







3656



  }










3657












3658



  SArray* aUidTags = pInfo->aUidTags;




5,596,670✔





3659



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




5,597,052✔





3660



  int32_t count = 0;




5,598,414✔





3661



  bool    ctbCursorFinished = false;




5,598,414✔





3662



  while (1) {




82,547✔





3663



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




5,680,961✔





3664



    taosArrayClear(aFilterIdxs);




5,675,933✔





3665












3666



    int32_t numTables = 0;




5,673,996✔





3667



    while (numTables < pOperator->resultInfo.capacity) {




14,269,856✔





3668



      SMCtbCursor* pCur = pInfo->pCtbCursor;




14,255,885✔





3669



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




14,254,851✔





3670



      if (uid == 0) {




14,271,849✔





3671



        ctbCursorFinished = true;




5,685,126✔





3672



        break;




5,685,126✔





3673



      }










3674



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




8,586,723✔





3675



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




8,579,016✔





3676



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




8,577,676✔





3677












3678



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




8,577,676✔





3679



      void* tmp = taosArrayPush(aUidTags, &info);




8,580,010✔





3680



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




8,580,010✔





3681



      ++numTables;




8,580,010✔





3682



    }










3683












3684



    if (numTables == 0) {




5,685,126✔





3685



      break;




153,139✔





3686



    }










3687



    bool ignoreFilterIdx = true;




5,531,987✔





3688



    if (pInfo->pTagCond != NULL) {




5,531,987✔





3689



      ignoreFilterIdx = false;




1,597,354✔





3690



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,597,354✔





3691



      QUERY_CHECK_CODE(code, lino, _end);




1,590,899✔





3692



    } else {










3693



      ignoreFilterIdx = true;




3,934,166✔





3694



    }










3695












3696



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




5,525,065✔





3697



    QUERY_CHECK_CODE(code, lino, _end);




5,528,756✔





3698












3699



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




5,528,756✔





3700












3701



    if (count != 0) {




5,528,265✔





3702



      break;




5,445,718✔





3703



    }










3704



  }










3705












3706



  if (count > 0) {




5,598,857✔





3707



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




5,445,227✔





3708



  }










3709



  if (count == 0 || ctbCursorFinished) {




5,598,291✔





3710



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




5,598,291✔





3711



    pInfo->pCtbCursor = NULL;




5,586,234✔





3712



    setOperatorCompleted(pOperator);




5,592,468✔





3713



  }










3714












3715



  pRes->info.rows = count;




5,595,360✔





3716



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,595,360✔





3717



  if (bLimitReached) {




5,590,989✔





3718



    setOperatorCompleted(pOperator);




×







3719



  }










3720












3721



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,590,989✔





3722



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,588,360✔





3723












3724



_end:




5,576,731✔





3725



  if (code != TSDB_CODE_SUCCESS) {




5,576,731✔





3726



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3727



    pTaskInfo->code = code;




×







3728



    T_LONG_JMP(pTaskInfo->env, code);




×







3729



  }










3730












3731



  return code;




5,576,731✔





3732



}










3733












3734



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,407,722✔





3735



  STagScanInfo*          pInfo = pOperator->info;




3,407,722✔





3736



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,407,722✔





3737



  int32_t                code = 0;




3,407,722✔





3738



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,407,722✔





3739



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,407,722✔





3740



  tb_uid_t               pUid = pParam->vcUid;




3,407,722✔





3741












3742



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3743



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3744



  //        pOperator->status);










3745












3746



  STableKeyInfo info = {.groupId = 0};




3,407,722✔





3747












3748



  int32_t tableIdx = 0;




3,407,722✔





3749



  taosHashClear(pListInfo->map);




3,407,722✔





3750



  taosArrayClear(pListInfo->pTableList);




3,407,722✔





3751












3752



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,407,722✔





3753



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3754



    } else {










3755



      return terrno;




×







3756



    }










3757



  }










3758












3759



  info.uid = pUid;




3,407,722✔





3760



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,407,722✔





3761



  if (p == NULL) {




3,407,722✔





3762



    return terrno;




×







3763



  }










3764












3765



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,407,722✔





3766












3767



  return code;




3,407,722✔





3768



}










3769












3770



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




12,135,267✔





3771



  int32_t       code = TSDB_CODE_SUCCESS;




12,135,267✔





3772



  int32_t       lino = 0;




12,135,267✔





3773



  STagScanInfo* pInfo = pOperator->info;




12,135,267✔





3774



  if (pOperator->pOperatorGetParam) {




12,134,776✔





3775



    pOperator->resultInfo.totalRows = 0;




3,407,722✔





3776



    pOperator->dynamicTask = true;




3,407,722✔





3777



    pInfo->curPos = 0;




3,407,722✔





3778



    code = createTagScanTableListInfoFromParam(pOperator);




3,407,722✔





3779



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,407,722✔





3780



    pOperator->pOperatorGetParam = NULL;




3,407,722✔





3781



    QUERY_CHECK_CODE(code, lino, _end);




3,407,722✔





3782












3783



    if (pOperator->status == OP_EXEC_DONE) {




3,407,722✔





3784



      pOperator->status = OP_OPENED;




1,827,379✔





3785



    }










3786



  }










3787












3788



  if (pOperator->status == OP_EXEC_DONE) {




12,134,959✔





3789



    (*ppRes) = NULL;




4,136,045✔





3790



    return code;




4,136,045✔





3791



  }










3792












3793



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




7,998,423✔





3794



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




7,998,914✔





3795












3796



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




7,998,423✔





3797



  SSDataBlock* pRes = pInfo->pRes;




7,997,316✔





3798



  blockDataCleanup(pRes);




7,998,298✔





3799












3800



  int32_t size = 0;




7,998,423✔





3801



  code = tableListGetSize(pInfo->pTableListInfo, &size);




7,998,423✔





3802



  QUERY_CHECK_CODE(code, lino, _end);




7,998,115✔





3803












3804



  if (size == 0) {




7,998,115✔





3805



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




17,741✔





3806



    (*ppRes) = NULL;




17,741✔





3807



    return code;




17,741✔





3808



  }










3809












3810



  SMetaReader mr = {0};




7,980,374✔





3811



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




7,980,374✔





3812



  pRes->info.rows = 0;




7,980,249✔





3813












3814



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




20,015,491✔





3815



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




12,034,607✔





3816



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




12,035,371✔





3817



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3818



      // ignore other error










3819



      code = TSDB_CODE_SUCCESS;




12,035,063✔





3820



    }










3821



    QUERY_CHECK_CODE(code, lino, _end);




12,035,371✔





3822












3823



    if (++pInfo->curPos >= size) {




12,035,371✔





3824



      setOperatorCompleted(pOperator);




7,981,173✔





3825



    }










3826



  }










3827












3828



  pAPI->metaReaderFn.clearReader(&mr);




7,981,668✔





3829



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




7,981,173✔





3830



  if (bLimitReached) {




7,981,173✔





3831



    setOperatorCompleted(pOperator);




×







3832



  }










3833












3834



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3835



  if (pOperator->status == OP_EXEC_DONE) {




7,981,173✔





3836



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




7,981,173✔





3837



  }










3838












3839



  pOperator->resultInfo.totalRows += pRes->info.rows;




7,981,173✔





3840












3841



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




7,981,173✔





3842



_end:




7,981,173✔





3843



  if (code != TSDB_CODE_SUCCESS) {




7,981,173✔





3844



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3845



    pTaskInfo->code = code;




×







3846



    T_LONG_JMP(pTaskInfo->env, code);




×







3847



  }










3848



  return code;




7,981,173✔





3849



}










3850












3851



static void destroyTagScanOperatorInfo(void* param) {




12,933,293✔





3852



  STagScanInfo* pInfo = (STagScanInfo*)param;




12,933,293✔





3853



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




12,933,293✔





3854



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3855



  }










3856



  taosHashCleanup(pInfo->filterCtx.colHash);




12,934,877✔





3857



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




12,924,375✔





3858



  taosArrayDestroy(pInfo->aFilterIdxs);




12,927,113✔





3859



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




12,927,182✔





3860












3861



  blockDataDestroy(pInfo->pRes);




12,933,314✔





3862



  taosArrayDestroy(pInfo->matchInfo.pList);




12,933,628✔





3863



  tableListDestroy(pInfo->pTableListInfo);




12,931,917✔





3864












3865



  pInfo->pRes = NULL;




12,934,687✔





3866



  pInfo->pTableListInfo = NULL;




12,934,320✔





3867



  taosMemoryFreeClear(param);




12,932,196✔





3868



}




12,931,975✔





3869












3870



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,724✔





3871



  int32_t         code = TSDB_CODE_SUCCESS;




4,724✔





3872



  STagScanInfo*   pInfo = pOper->info;




4,724✔





3873












3874



  pOper->status = OP_NOT_OPENED;




4,724✔





3875



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,724✔





3876



  if (pTagScanNode->onlyMetaCtbIdx) {




4,724✔





3877



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




1,968✔





3878



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,968✔





3879



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




1,968✔





3880



      pInfo->pCtbCursor = NULL;




1,968✔





3881



  } else {










3882



      pInfo->curPos = 0;




2,756✔





3883



  }










3884












3885



  return code;




4,724✔





3886



}










3887












3888



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




12,925,741✔





3889



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3890



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3891



  QRY_PARAM_CHECK(pOptrInfo);




12,925,741✔





3892












3893



  int32_t         code = TSDB_CODE_SUCCESS;




12,931,615✔





3894



  int32_t         lino = 0;




12,931,615✔





3895



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




12,931,615✔





3896



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




12,931,615✔





3897



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




12,919,862✔





3898



  if (pInfo == NULL || pOperator == NULL) {




12,912,259✔





3899



    code = terrno;




×







3900



    goto _error;




×







3901



  }










3902



  pOperator->pPhyNode = pTagScanNode;




12,913,257✔





3903



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




12,914,200✔





3904












3905



  int32_t    numOfExprs = 0;




12,918,041✔





3906



  SExprInfo* pExprInfo = NULL;




12,921,451✔





3907












3908



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




12,921,451✔





3909



  QUERY_CHECK_CODE(code, lino, _error);




12,922,920✔





3910












3911



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




12,922,920✔





3912



  QUERY_CHECK_CODE(code, lino, _error);




12,920,315✔





3913












3914



  int32_t num = 0;




12,920,315✔





3915



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




12,922,740✔





3916



  QUERY_CHECK_CODE(code, lino, _error);




12,924,308✔





3917












3918



  pInfo->pTagCond = pTagCond;




12,924,308✔





3919



  pInfo->pTagIndexCond = pTagIndexCond;




12,926,161✔





3920



  pInfo->suid = pPhyNode->suid;




12,921,517✔





3921



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




12,918,160✔





3922












3923



  pInfo->pTableListInfo = pTableListInfo;




12,912,809✔





3924



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




12,928,989✔





3925



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




12,937,676✔





3926












3927



  pInfo->readHandle = *pReadHandle;




12,914,426✔





3928



  pInfo->curPos = 0;




12,935,736✔





3929












3930



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




12,913,138✔





3931



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




12,912,100✔





3932



                  pTaskInfo);










3933



  initResultSizeInfo(&pOperator->resultInfo, 4096);




12,901,672✔





3934



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




12,918,091✔





3935



  QUERY_CHECK_CODE(code, lino, _error);




12,926,037✔





3936












3937



  if (pTagScanNode->onlyMetaCtbIdx) {




12,926,037✔





3938



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




6,004,108✔





3939



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




6,016,230✔





3940












3941



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




6,012,820✔





3942



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




6,013,030✔





3943












3944



    pInfo->filterCtx.colHash =




6,010,345✔





3945



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




6,011,751✔





3946



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




6,013,938✔





3947












3948



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




6,007,695✔





3949



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




6,012,109✔





3950












3951



    if (pInfo->pTagCond != NULL) {




6,005,328✔





3952



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,600,217✔





3953



    }










3954



  }










3955



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




12,931,650✔





3956



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




12,931,262✔





3957



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










3958



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




12,925,852✔





3959



  










3960



  *pOptrInfo = pOperator;




12,926,839✔





3961



  return code;




12,924,990✔





3962












3963



_error:




×







3964



  if (pInfo) {




×







3965



    pInfo->pTableListInfo = NULL;




×







3966



  }










3967












3968



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







3969



  if (pOperator != NULL) {




×







3970



    pOperator->info = NULL;




×







3971



    destroyOperator(pOperator);




×







3972



  }










3973



  return code;




×







3974



}










3975












3976



// table merge scan operator










3977












3978



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




231,850,710✔





3979



  int32_t                 left = *(int32_t*)pLeft;




231,850,710✔





3980



  int32_t                 right = *(int32_t*)pRight;




231,851,760✔





3981



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




231,852,110✔





3982












3983



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




231,852,110✔





3984



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




231,853,160✔





3985












3986



  if (leftIdx == -1) {




231,852,460✔





3987



    return 1;




198,595,180✔





3988



  } else if (rightIdx == -1) {




33,257,280✔





3989



    return -1;




329,280✔





3990



  }










3991












3992



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




32,928,000✔





3993



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




32,928,000✔





3994



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




32,928,000✔





3995



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




32,928,000✔





3996



    ret = -1 * ret;




×







3997



  }










3998



  return ret;




32,928,000✔





3999



}










4000












4001



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







4002



  int32_t                 left = *(int32_t*)pLeft;




×







4003



  int32_t                 right = *(int32_t*)pRight;




×







4004



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4005












4006



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4007



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4008












4009



  if (leftIdx == -1) {




×







4010



    return 1;




×







4011



  } else if (rightIdx == -1) {




×







4012



    return -1;




×







4013



  }










4014












4015



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4016



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4017



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4018



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4019



    ret = -1 * ret;




×







4020



  }










4021



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4022



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4023



                               pInfo->pPkOrderInfo);




×







4024



  }










4025



  return ret;




×







4026



}










4027












4028



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




2,948,337✔





4029



  int32_t code = TSDB_CODE_SUCCESS;




2,948,337✔





4030



  int32_t lino = 0;




2,948,337✔





4031



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




2,948,337✔





4032



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




2,948,337✔





4033



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




2,949,051✔





4034



  for (int i = 0; i < src->numOfCols; i++) {




9,727,851✔





4035



    dst->colList[i] = src->colList[i];




6,803,895✔





4036



  }










4037












4038



_end:




2,941,498✔





4039



  if (code != TSDB_CODE_SUCCESS) {




2,941,498✔





4040



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4041



  }










4042



  return code;




2,940,091✔





4043



}










4044












4045



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,424,588✔





4046



                                                bool* pSubTableHasBlock) {










4047



  int32_t code = 0;




4,424,588✔





4048












4049



  STableMergeScanInfo*    pInfo = pOperator->info;




4,424,588✔





4050



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,425,974✔





4051



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,424,252✔





4052



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,422,873✔





4053



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,424,252✔





4054












4055



  blockDataCleanup(pInput->pReaderBlock);




4,426,317✔





4056



  if (!pInput->bInMemReader) {




4,422,544✔





4057



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,440,163✔





4058



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,219,560✔





4059



    if (code != 0) {




2,220,239✔





4060



      return code;




×







4061



    }










4062



  }










4063












4064



  pInfo->base.dataReader = pInput->pReader;




4,421,844✔





4065












4066



  while (true) {




10,150✔





4067



    bool hasNext = false;




4,435,445✔





4068



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,436,138✔





4069



    if (code != 0) {




4,436,152✔





4070



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4071



      pInfo->base.dataReader = NULL;




×







4072



      return code;




×







4073



    }










4074












4075



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,436,152✔





4076



      if (isTaskKilled(pTaskInfo)) {




2,956,282✔





4077



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4078



        pInfo->base.dataReader = NULL;




×







4079



        return code;




×







4080



      }










4081












4082



      *pSubTableHasBlock = false;




2,957,997✔





4083



      break;




2,957,997✔





4084



    }










4085












4086



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,479,870✔





4087



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,451,170✔





4088



    } else {










4089



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




28,700✔





4090



    }










4091












4092



    uint32_t status = 0;




1,479,870✔





4093



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,479,870✔





4094



    if (code != 0) {




1,479,870✔





4095



      pInfo->base.dataReader = NULL;




×







4096



      return code;




×







4097



    }










4098












4099



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,479,870✔





4100



      *pSubTableHasBlock = false;




×







4101



      break;




×







4102



    }










4103



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,479,870✔





4104



      continue;




10,150✔





4105



    }










4106












4107



    *pSubTableHasBlock = true;




1,469,720✔





4108



    break;




1,469,720✔





4109



  }










4110












4111



  if (*pSubTableHasBlock) {




4,427,717✔





4112



    pInput->pReaderBlock->info.id.groupId =




2,939,440✔





4113



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




2,939,440✔





4114



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,469,720✔





4115



  }










4116



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,427,717✔





4117



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,329,207✔





4118



    pInput->pReader = NULL;




3,326,463✔





4119



  }










4120












4121



  pInfo->base.dataReader = NULL;




4,426,002✔





4122



  return TSDB_CODE_SUCCESS;




4,424,287✔





4123



}










4124












4125



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,843,184✔





4126



  pInfo->bGroupProcessed = false;




1,843,184✔





4127












4128



  int32_t numOfTables = 0;




1,846,278✔





4129



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,822,219✔





4130



  if (code != TSDB_CODE_SUCCESS) {




1,819,475✔





4131



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4132



    return code;




×







4133



  }










4134












4135



  int32_t i = pInfo->tableStartIndex + 1;




1,819,475✔





4136



  for (; i < numOfTables; ++i) {




2,930,116✔





4137



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,163,120✔





4138



    if (!tableKeyInfo) {




1,162,770✔





4139



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4140



      return terrno;




×







4141



    }










4142



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,162,770✔





4143



      break;




58,310✔





4144



    }










4145



  }










4146



  pInfo->tableEndIndex = i - 1;




1,825,306✔





4147



  return TSDB_CODE_SUCCESS;




1,846,957✔





4148



}










4149












4150



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,852,144✔





4151



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,809,448✔





4152



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,958,340✔





4153



    if (pInput->rowIdx == -1) {




2,955,253✔





4154



      continue;




1,488,620✔





4155



    }










4156












4157



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,469,720✔





4158



      pInput->rowIdx = 0;




1,469,720✔





4159



      pInput->pageIdx = -1;




1,469,377✔





4160



    }










4161












4162



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,469,370✔





4163



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,469,370✔





4164



    if (!col) {




1,469,720✔





4165



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4166



      return terrno;




×







4167



    }










4168



    pInput->aTs = (int64_t*)col->pData;




1,469,720✔





4169



  }










4170












4171



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,852,487✔





4172



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,852,830✔





4173



}










4174












4175



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,841,812✔





4176



  int32_t code = setGroupStartEndIndex(pInfo);




1,841,812✔





4177



  if (code != TSDB_CODE_SUCCESS) {




1,845,228✔





4178



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4179



    return code;




×







4180



  }










4181



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,845,228✔





4182



  if (pSubTblsInfo == NULL) {




1,838,039✔





4183



    return terrno;




×







4184



  }










4185



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,838,039✔





4186



  if (!pSubTblsInfo->pTsOrderInfo) {




1,841,133✔





4187



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4188



    return terrno;




×







4189



  }










4190



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,842,841✔





4191



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4192



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4193



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4194



      return terrno;




×







4195



    }










4196



  } else {










4197



    pSubTblsInfo->pPkOrderInfo = NULL;




1,828,708✔





4198



  }










4199



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,843,527✔





4200



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,830,444✔





4201



  if (pSubTblsInfo->aInputs == NULL) {




1,823,598✔





4202



    taosMemoryFree(pSubTblsInfo);




×







4203



    return terrno;




×







4204



  }










4205



  int32_t bufPageSize = pInfo->bufPageSize;




1,829,072✔





4206



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,839,390✔





4207



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,843,877✔





4208



  if (code != TSDB_CODE_SUCCESS) {




1,835,946✔





4209



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4210



    taosMemoryFree(pSubTblsInfo);




×







4211



    return code;




×







4212



  }










4213



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,835,946✔





4214



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,848,343✔





4215












4216



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,834,238✔





4217



  return TSDB_CODE_SUCCESS;




1,824,564✔





4218



}










4219












4220



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,838,690✔





4221



  int32_t        code = TSDB_CODE_SUCCESS;




1,838,690✔





4222



  int32_t        lino = 0;




1,838,690✔





4223



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,838,690✔





4224



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,840,076✔





4225



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,842,820✔





4226












4227



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,848,007✔





4228












4229



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,776,408✔





4230



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,952,488✔





4231



    pInput->type = SUB_TABLE_MEM_BLOCK;




2,933,196✔





4232












4233



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




2,949,730✔





4234



    QUERY_CHECK_CODE(code, lino, _end);




2,934,960✔





4235












4236



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




2,934,960✔





4237



    QUERY_CHECK_CODE(code, lino, _end);




2,956,282✔





4238












4239



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




2,956,282✔





4240



    QUERY_CHECK_CODE(code, lino, _end);




2,957,311✔





4241












4242



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




2,957,311✔





4243



    pInput->pKeyInfo = keyInfo;




2,955,253✔





4244












4245



    if (isTaskKilled(pTaskInfo)) {




2,953,174✔





4246



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4247



    }










4248












4249



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




2,948,358✔





4250



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,209,270✔





4251



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,105,160✔





4252



      QUERY_CHECK_CODE(code, lino, _end);




1,103,760✔





4253



      pInput->bInMemReader = true;




1,103,760✔





4254



    } else {










4255



      pInput->pReader = NULL;




1,850,065✔





4256



      pInput->bInMemReader = false;




1,850,415✔





4257



    }










4258



    bool hasNext = true;




2,953,825✔





4259



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




2,954,511✔





4260



    QUERY_CHECK_CODE(code, lino, _end);




2,956,625✔





4261



    if (!hasNext) {




2,956,625✔





4262



      pInput->rowIdx = -1;




1,486,905✔





4263



      ++pSubTblsInfo->numSubTablesCompleted;




1,487,934✔





4264



      continue;




1,486,905✔





4265



    } else {










4266



      pInput->rowIdx = 0;




1,469,720✔





4267



      pInput->pageIdx = -1;




1,469,720✔





4268



    }










4269



  }










4270












4271



_end:




1,851,801✔





4272



  if (code != TSDB_CODE_SUCCESS) {




1,851,458✔





4273



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4274



  }










4275



  return code;




1,851,801✔





4276



}










4277












4278



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,469,720✔





4279



  int32_t              code = TSDB_CODE_SUCCESS;




1,469,720✔





4280



  int32_t              lino = 0;




1,469,720✔





4281



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,469,720✔





4282



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,469,720✔





4283



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,469,720✔





4284



  bool                 hasNext = true;




1,469,720✔





4285



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,469,720✔





4286



  QUERY_CHECK_CODE(code, lino, _end);




1,469,720✔





4287












4288



  if (!hasNext) {




1,469,720✔





4289



    pInput->rowIdx = -1;




1,469,720✔





4290



    ++pSubTblsInfo->numSubTablesCompleted;




1,469,370✔





4291



  } else {










4292



    pInput->rowIdx = 0;




×







4293



  }










4294












4295



_end:




1,469,370✔





4296



  if (code != TSDB_CODE_SUCCESS) {




1,469,720✔





4297



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4298



    pTaskInfo->code = code;




×







4299



    T_LONG_JMP(pTaskInfo->env, code);




×







4300



  }










4301



}




1,469,720✔





4302












4303



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




267,493,744✔





4304



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




267,493,744✔





4305



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




267,495,130✔





4306












4307



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




267,493,380✔





4308



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




267,517,880✔





4309



    ++pInput->rowIdx;




266,046,431✔





4310



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,469,720✔





4311



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,469,720✔





4312



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,469,720✔





4313



    }










4314



    if (pInput->rowIdx != -1) {




1,469,720✔





4315



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4316



      if (!col) {




×







4317



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4318



        return terrno;




×







4319



      }










4320



      pInput->pInputBlock = pInputBlock;




×







4321



      pInput->aTs = (int64_t*)col->pData;




×







4322



    }










4323



  }










4324












4325



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




267,514,072✔





4326



}










4327












4328



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




267,308,636✔





4329



  int32_t            code = TSDB_CODE_SUCCESS;




267,308,636✔





4330



  int32_t            lino = 0;




267,308,636✔





4331



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




267,308,636✔





4332



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




267,360,100✔





4333












4334



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,097,102,146✔





4335



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




829,191,650✔





4336



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




829,145,583✔





4337












4338



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




829,145,583✔





4339



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




828,760,828✔





4340



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




828,760,828✔





4341












4342



    if (isNull) {




829,368,106✔





4343



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




116,762,828✔





4344



      QUERY_CHECK_CODE(code, lino, _end);




116,779,614✔





4345



    } else {










4346



      if (pSrcColInfo->pData != NULL) {




712,605,278✔





4347



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




712,619,299✔





4348



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




713,438,803✔





4349



        QUERY_CHECK_CODE(code, lino, _end);




712,904,857✔





4350



      }










4351



    }










4352



  }










4353



  pBlock->info.dataLoad = 1;




267,496,824✔





4354



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




267,497,174✔





4355



  pBlock->info.rows += 1;




267,498,224✔





4356












4357



_end:




267,496,516✔





4358



  if (code != TSDB_CODE_SUCCESS) {




267,496,516✔





4359



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4360



  }










4361



  return code;




267,492,708✔





4362



}










4363












4364



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




2,991,555✔





4365



                                       SSDataBlock** pResBlock) {










4366



  int32_t                 code = TSDB_CODE_SUCCESS;




2,991,555✔





4367



  int32_t                 lino = 0;




2,991,555✔





4368



  STableMergeScanInfo*    pInfo = pOperator->info;




2,991,555✔





4369



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




2,992,584✔





4370



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




2,991,898✔





4371



  bool                    finished = false;




2,991,555✔





4372












4373



  QRY_PARAM_CHECK(pResBlock);




2,991,555✔





4374












4375



  blockDataCleanup(pBlock);




2,990,862✔





4376












4377



  while (true) {




×







4378



    while (true) {










4379



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




270,320,162✔





4380



        finished = true;




2,992,927✔





4381



        break;




2,992,927✔





4382



      }










4383












4384



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




267,327,529✔





4385



      QUERY_CHECK_CODE(code, lino, _end);




267,478,981✔





4386












4387



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




267,478,981✔





4388



      QUERY_CHECK_CODE(code, lino, _end);




267,333,059✔





4389












4390



      if (pBlock->info.rows >= capacity) {




267,333,059✔





4391



        break;




×







4392



      }










4393



    }










4394












4395



    if (isTaskKilled(pTaskInfo)) {




2,992,927✔





4396



      return pTaskInfo->code;




×







4397



    }










4398












4399



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




2,992,577✔





4400



    if (finished || limitReached || pBlock->info.rows > 0) {




2,992,584✔





4401



      break;










4402



    }










4403



  }










4404












4405



  if (pBlock->info.rows > 0) {




2,992,584✔





4406



    *pResBlock = pBlock;




1,140,090✔





4407



  }










4408












4409



_end:




1,852,144✔





4410



  if (code != TSDB_CODE_SUCCESS) {




2,992,584✔





4411



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4412



    pTaskInfo->code = code;




×







4413



  }










4414



  return code;




2,992,241✔





4415



}










4416












4417



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,843,534✔





4418



  int32_t              code = TSDB_CODE_SUCCESS;




1,843,534✔





4419



  int32_t              lino = 0;




1,843,534✔





4420



  STableMergeScanInfo* pInfo = pOperator->info;




1,843,534✔





4421












4422



  code = initSubTablesMergeInfo(pInfo);




1,844,906✔





4423



  QUERY_CHECK_CODE(code, lino, _end);




1,821,841✔





4424












4425



  code = initSubTableInputs(pOperator, pInfo);




1,821,841✔





4426



  QUERY_CHECK_CODE(code, lino, _end);




1,851,458✔





4427












4428



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,851,458✔





4429



  QUERY_CHECK_CODE(code, lino, _end);




1,850,765✔





4430












4431



_end:




1,850,765✔





4432



  if (code != TSDB_CODE_SUCCESS) {




1,850,765✔





4433



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4434



  }










4435



  return code;




1,852,144✔





4436



}










4437












4438



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




32,820,338✔





4439



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




32,820,338✔





4440



  if (pSubTblsInfo != NULL) {




32,819,916✔





4441



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,851,115✔





4442












4443



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,807,740✔





4444



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,957,654✔





4445



      taosMemoryFree(pInput->tblCond.colList);




2,955,939✔





4446



      blockDataDestroy(pInput->pReaderBlock);




2,955,596✔





4447



      blockDataDestroy(pInput->pPageBlock);




2,956,282✔





4448



      taosArrayDestroy(pInput->aBlockPages);




2,957,311✔





4449



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




2,957,311✔





4450



      pInput->pReader = NULL;




2,956,968✔





4451



    }










4452












4453



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,851,801✔





4454



    taosMemoryFree(pSubTblsInfo->aInputs);




1,850,422✔





4455












4456



    taosMemoryFree(pSubTblsInfo);




1,849,743✔





4457



    pInfo->pSubTablesMergeInfo = NULL;




1,849,057✔





4458












4459



    // taosMemoryTrim(0);










4460



  }










4461



}




32,818,537✔





4462












4463



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




2,973,950✔





4464



  QRY_PARAM_CHECK(ppRes);




2,973,950✔





4465












4466



  int32_t lino = 0;




2,973,607✔





4467



  int32_t tableListSize = 0;




2,973,607✔





4468



  int64_t st = taosGetTimestampUs();




2,961,581✔





4469












4470



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




2,961,581✔





4471



  STableMergeScanInfo* pInfo = pOperator->info;




2,973,950✔





4472












4473



  if (pOperator->status == OP_EXEC_DONE) {




2,978,780✔





4474



    return TSDB_CODE_SUCCESS;




×







4475



  }










4476












4477



  int32_t code = pOperator->fpSet._openFn(pOperator);




2,948,512✔





4478



  QUERY_CHECK_CODE(code, lino, _end);




2,971,885✔





4479












4480



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




2,971,885✔





4481



  QUERY_CHECK_CODE(code, lino, _end);




2,965,368✔





4482












4483



  if (!pInfo->hasGroupId) {




2,965,368✔





4484



    pInfo->hasGroupId = true;




1,829,716✔





4485












4486



    if (tableListSize == 0) {




1,816,010✔





4487



      setOperatorCompleted(pOperator);




48,300✔





4488



      (*ppRes) = NULL;




47,600✔





4489



      return code;




47,600✔





4490



    }










4491












4492



    pInfo->tableStartIndex = 0;




1,767,710✔





4493



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,767,017✔





4494



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,756,692✔





4495



    pInfo->groupId = pTmpGpId->groupId;




1,756,692✔





4496



    code = startSubTablesTableMergeScan(pOperator);




1,786,596✔





4497



    QUERY_CHECK_CODE(code, lino, _end);




1,792,448✔





4498



  }










4499












4500



  SSDataBlock* pBlock = NULL;




2,929,472✔





4501



  while (pInfo->tableStartIndex < tableListSize) {




2,991,891✔





4502



    if (isTaskKilled(pTaskInfo)) {




2,992,584✔





4503



      break;




×







4504



    }










4505












4506



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




2,990,519✔





4507



    QUERY_CHECK_CODE(code, lino, _end);




2,992,241✔





4508












4509



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




2,992,241✔





4510



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4511



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4512












4513



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4514



    }










4515












4516



    if (pBlock != NULL) {




2,992,584✔





4517



      pBlock->info.id.groupId = pInfo->groupId;




1,140,440✔





4518



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,140,440✔





4519



      pInfo->bGroupProcessed = true;




1,140,440✔





4520



      break;




1,140,090✔





4521



    } else {










4522



      // Data of this group are all dumped, let's try the next group










4523



      stopSubTablesTableMergeScan(pInfo);




1,852,144✔





4524



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,851,801✔





4525



        setOperatorCompleted(pOperator);




1,792,112✔





4526



        break;




1,792,448✔





4527



      }










4528












4529



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




58,660✔





4530



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




58,660✔





4531



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




58,660✔





4532












4533



      pInfo->groupId = pTmpGpId->groupId;




58,660✔





4534



      code = startSubTablesTableMergeScan(pOperator);




58,660✔





4535



      QUERY_CHECK_CODE(code, lino, _end);




58,660✔





4536



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




58,660✔





4537



    }










4538



  }










4539












4540



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




2,933,924✔





4541












4542



_end:




2,932,209✔





4543



  if (code != TSDB_CODE_SUCCESS) {




2,931,852✔





4544



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4545



    pTaskInfo->code = code;




×







4546



    T_LONG_JMP(pTaskInfo->env, code);




×







4547



  } else {










4548



    (*ppRes) = pBlock;




2,931,852✔





4549



  }










4550












4551



  return code;




2,932,202✔





4552



}










4553












4554



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,454,691✔





4555



  int32_t              code = TSDB_CODE_SUCCESS;




3,454,691✔





4556



  int32_t              lino = 0;




3,454,691✔





4557



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,454,691✔





4558



  STableMergeScanInfo* pInfo = pOperator->info;




3,454,691✔





4559



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,454,691✔





4560












4561



  if (pInfo->mSkipTables == NULL) {




3,454,691✔





4562



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




286,365✔





4563



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4564



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




286,365✔





4565



  }










4566



  int bSkip = 1;




3,454,691✔





4567



  if (pInfo->mSkipTables != NULL) {




3,454,691✔





4568



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,454,691✔





4569



    if (code == TSDB_CODE_DUP_KEY) {




3,454,691✔





4570



      code = TSDB_CODE_SUCCESS;




×







4571



    }










4572



    QUERY_CHECK_CODE(code, lino, _end);




3,454,691✔





4573



  }










4574












4575



_end:




3,454,691✔





4576



  if (code != TSDB_CODE_SUCCESS) {




3,454,691✔





4577



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4578



    pTaskInfo->code = code;




×







4579



    T_LONG_JMP(pTaskInfo->env, code);




×







4580



  }










4581



}




3,454,691✔





4582












4583



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




176,658,355✔





4584



  STableMergeScanInfo* pInfo = pOperator->info;




176,658,355✔





4585



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




176,669,479✔





4586



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




176,656,083✔





4587



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




176,665,299✔





4588



  int32_t              code = 0;




176,654,316✔





4589



  bool                 hasNext = false;




176,654,316✔





4590



  STsdbReader*         reader = pInfo->base.dataReader;




176,653,530✔





4591












4592



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




176,640,543✔





4593



  if (code != 0) {




176,642,830✔





4594



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4595



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4596



    pTaskInfo->code = code;




×







4597



    return code;




×







4598



  }










4599












4600



  if (!hasNext || isTaskKilled(pTaskInfo)) {




176,642,830✔





4601



    if (isTaskKilled(pTaskInfo)) {




32,368,036✔





4602



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




1,362✔





4603



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




1,362✔





4604



    }










4605



    *pFinished = true;




32,337,030✔





4606



    return code;




32,335,592✔





4607



  }










4608












4609



  uint32_t status = 0;




144,296,278✔





4610



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




144,298,268✔





4611












4612



  if (code != TSDB_CODE_SUCCESS) {




144,279,756✔





4613



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




112,888✔





4614



    pTaskInfo->code = code;




112,888✔





4615



    return code;




112,888✔





4616



  }










4617












4618



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




144,166,868✔





4619



    *pFinished = true;




×







4620



    return code;




×







4621



  }










4622












4623



  // current block is filter out according to filter condition, continue load the next block










4624



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




144,166,868✔





4625



    *pSkipped = true;




7,291,209✔





4626



    return code;




7,328,570✔





4627



  }










4628












4629



  return code;




136,853,768✔





4630



}










4631












4632



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




179,295,706✔





4633



  STableMergeScanSortSourceParam* source = param;




179,295,706✔





4634












4635



  SOperatorInfo*       pOperator = source->pOperator;




179,295,706✔





4636



  STableMergeScanInfo* pInfo = pOperator->info;




179,296,331✔





4637



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




179,293,925✔





4638



  SSDataBlock*         pBlock = NULL;




179,283,071✔





4639



  int64_t              st = taosGetTimestampUs();




179,290,179✔





4640



  int32_t              code = TSDB_CODE_SUCCESS;




179,290,179✔





4641












4642



  while (true) {










4643



    if (pInfo->rtnNextDurationBlocks) {




195,578,347✔





4644



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




18,918,848✔





4645



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4646












4647



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




18,923,808✔





4648



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




8,960,640✔





4649



        ++pInfo->nextDurationBlocksIdx;




8,960,640✔





4650



      } else {










4651



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




18,921,481✔





4652



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




8,959,598✔





4653



          pInfo->nextDurationBlocks[i] = NULL;




8,959,598✔





4654



        }










4655












4656



        pInfo->rtnNextDurationBlocks = false;




9,961,883✔





4657



        pInfo->nextDurationBlocksIdx = 0;




9,961,883✔





4658



        pInfo->numNextDurationBlocks = 0;




9,961,883✔





4659



        continue;




9,961,883✔





4660



      }










4661



    } else {










4662



      bool bFinished = false;




176,653,280✔





4663



      bool bSkipped = false;




176,659,934✔





4664












4665



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




176,671,846✔





4666



      if (code != 0) {




176,631,993✔





4667



        return code;




112,888✔





4668



      }










4669












4670



      pBlock = pInfo->pReaderBlock;




176,519,105✔





4671



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




176,518,448✔





4672



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4673



      if (bFinished) {




176,521,721✔





4674



        pInfo->bNewFilesetEvent = false;




32,337,258✔





4675



        break;




32,337,712✔





4676



      }










4677












4678



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




144,184,463✔





4679



        if (!bSkipped) {




9,951,228✔





4680



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




8,960,640✔





4681



          if (code) {




8,960,640✔





4682



            *ppBlock = NULL;




×







4683



            return code;




×







4684



          }










4685












4686



          ++pInfo->numNextDurationBlocks;




8,960,640✔





4687



          if (pInfo->numNextDurationBlocks > 2) {




8,960,640✔





4688



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4689



                   pInfo->numNextDurationBlocks);










4690



            pInfo->bNewFilesetEvent = false;




×







4691



            break;




×







4692



          }










4693



        }










4694












4695



        if (pInfo->bNewFilesetEvent) {




9,951,228✔





4696



          pInfo->rtnNextDurationBlocks = true;




9,962,925✔





4697



          *ppBlock = NULL;




9,962,925✔





4698



          return code;




9,962,925✔





4699



        }










4700













UNCOV

4701



        if (pInfo->bNextDurationBlockEvent) {




×







4702



          pInfo->bNextDurationBlockEvent = false;




×







4703



          continue;




×







4704



        }










4705



      }










4706



      if (bSkipped) continue;




134,239,288✔





4707



    }










4708












4709



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




136,858,438✔





4710












4711



    pOperator->resultInfo.totalRows += pBlock->info.rows;




136,897,743✔





4712



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




136,871,401✔





4713



    *ppBlock = pBlock;




136,855,910✔





4714












4715



    return code;




136,846,621✔





4716



  }










4717












4718



  *ppBlock = NULL;




32,335,687✔





4719



  return code;




32,335,724✔





4720



}










4721












4722



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




28,646,467✔





4723



  int32_t code = TSDB_CODE_SUCCESS;




28,646,467✔





4724



  int32_t lino = 0;




28,646,467✔





4725



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




28,646,467✔





4726



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




28,584,875✔





4727



  SBlockOrderInfo biTs = {0};




28,584,875✔





4728



  SBlockOrderInfo biPk = {0};




28,601,747✔





4729












4730



  int32_t tsTargetSlotId = 0;




28,610,599✔





4731



  int32_t pkTargetSlotId = -1;




28,610,599✔





4732



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




102,669,837✔





4733



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




74,154,325✔





4734



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




74,156,459✔





4735



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




74,156,459✔





4736



      tsTargetSlotId = colInfo->dstSlotId;




28,646,284✔





4737



      biTs.order = order;




28,666,423✔





4738



      biTs.slotId = tsTargetSlotId;




28,666,423✔





4739



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




28,666,423✔





4740



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




28,666,423✔





4741



    }










4742



    // TODO: order by just ts










4743



    if (colInfo->isPk) {




74,093,106✔





4744



      pkTargetSlotId = colInfo->dstSlotId;




2,081,811✔





4745



      biPk.order = order;




2,081,811✔





4746



      biPk.slotId = pkTargetSlotId;




2,081,811✔





4747



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




2,081,811✔





4748



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




2,081,811✔





4749



    }










4750



  }










4751












4752



  void* tmp = taosArrayPush(pSortInfo, &biTs);




28,655,854✔





4753



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




28,655,854✔





4754



  if (pkTargetSlotId != -1) {




28,655,854✔





4755



    tmp = taosArrayPush(pSortInfo, &biPk);




2,082,386✔





4756



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,082,386✔





4757



  }










4758












4759



  (*ppSortArray) = pSortInfo;




28,655,854✔





4760












4761



_end:




28,600,320✔





4762



  if (code != TSDB_CODE_SUCCESS) {




28,631,071✔





4763



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4764



  }










4765



  return code;




28,631,071✔





4766



}










4767












4768



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




34,164,112✔





4769



  STableMergeScanInfo* pTmsInfo = param;




34,164,112✔





4770



  if (type == TSD_READER_NOTIFY_DURATION_START) {




34,164,112✔





4771



    pTmsInfo->bNewFilesetEvent = true;




34,170,832✔





4772



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4773



    pTmsInfo->bNextDurationBlockEvent = true;




×







4774



  }










4775



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




34,164,748✔





4776












4777



  return;




34,184,017✔





4778



}










4779












4780



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




42,369,679✔





4781



  STableMergeScanInfo* pInfo = pOperator->info;




42,369,679✔





4782



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




42,395,280✔





4783












4784



  int32_t code = TSDB_CODE_SUCCESS;




42,392,201✔





4785



  int32_t lino = 0;




42,392,201✔





4786



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




42,392,201✔





4787












4788



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




42,366,670✔





4789



  pInfo->bNewFilesetEvent = false;




42,381,599✔





4790



  pInfo->bNextDurationBlockEvent = false;




42,384,648✔





4791












4792



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




42,374,905✔





4793



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




42,373,115✔





4794












4795



  pInfo->pSortHandle = NULL;




42,356,385✔





4796



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




84,759,011✔





4797



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




42,379,049✔





4798



  if (code) {




42,300,649✔





4799



    return code;




×







4800



  }










4801












4802



  if (pInfo->bSortRowId && numOfTable != 1) {




42,300,649✔





4803



    int32_t memSize = 512 * 1024 * 1024;




3,660,942✔





4804



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




3,660,942✔





4805



    QUERY_CHECK_CODE(code, lino, _end);




3,662,176✔





4806



  }










4807












4808



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




42,314,816✔





4809



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




42,286,250✔





4810



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




42,239,996✔





4811












4812



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




42,236,539✔





4813



  QUERY_CHECK_CODE(code, lino, _end);




42,273,542✔





4814












4815



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




42,273,542✔





4816



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




42,257,317✔





4817



  param->pOperator = pOperator;




42,257,317✔





4818












4819



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




42,290,920✔





4820



  if (ps == NULL) {




42,236,434✔





4821



    taosMemoryFree(param);




×







4822



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4823



  }










4824












4825



  ps->param = param;




42,236,434✔





4826



  ps->onlyRef = false;




42,324,450✔





4827



  code = tsortAddSource(pInfo->pSortHandle, ps);




42,298,384✔





4828



  QUERY_CHECK_CODE(code, lino, _end);




42,392,866✔





4829












4830



  if (numOfTable == 1) {




42,392,866✔





4831



    tsortSetSingleTableMerge(pInfo->pSortHandle);




27,929,339✔





4832



  } else {










4833



    code = tsortOpen(pInfo->pSortHandle);




14,463,527✔





4834



    QUERY_CHECK_CODE(code, lino, _end);




14,469,914✔





4835



  }










4836












4837



_end:




14,412,562✔





4838



  if (code != TSDB_CODE_SUCCESS) {




42,388,750✔





4839



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




57,352✔





4840



  }










4841



  return code;




42,401,183✔





4842



}










4843












4844



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




42,301,262✔





4845



  STableMergeScanInfo* pInfo = pOperator->info;




42,301,262✔





4846



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




42,299,760✔





4847



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




42,296,157✔





4848












4849



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




42,295,179✔





4850



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




42,291,089✔





4851



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




42,289,152✔





4852



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




42,292,979✔





4853



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




42,289,310✔





4854



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




42,286,594✔





4855












4856



  tsortDestroySortHandle(pInfo->pSortHandle);




42,294,465✔





4857



  pInfo->pSortHandle = NULL;




42,293,016✔





4858



}




42,292,562✔





4859












4860



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




32,390,996✔





4861



  int32_t              code = TSDB_CODE_SUCCESS;




32,390,996✔





4862



  int32_t              lino = 0;




32,390,996✔





4863



  STableMergeScanInfo* pInfo = pOperator->info;




32,390,996✔





4864



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




32,403,056✔





4865



  SReadHandle*         pHandle = &pInfo->base.readHandle;




32,349,691✔





4866



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




32,315,225✔





4867



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




32,388,184✔





4868












4869



  {










4870



    int32_t numOfTables = 0;




32,390,584✔





4871



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




32,321,724✔





4872



    QUERY_CHECK_CODE(code, lino, _end);




32,341,669✔





4873












4874



    int32_t i = pInfo->tableStartIndex + 1;




32,341,669✔





4875



    for (; i < numOfTables; ++i) {




139,692,132✔





4876



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




113,374,717✔





4877



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




113,373,787✔





4878



      if (tableKeyInfo->groupId != pInfo->groupId) {




113,373,787✔





4879



        break;




6,019,062✔





4880



      }










4881



    }










4882



    pInfo->tableEndIndex = i - 1;




32,336,477✔





4883



  }










4884



  pInfo->bGroupProcessed = false;




32,429,158✔





4885



  int32_t tableStartIdx = pInfo->tableStartIndex;




32,433,540✔





4886



  int32_t tableEndIdx = pInfo->tableEndIndex;




32,423,155✔





4887












4888



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




32,434,587✔





4889



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




32,434,587✔





4890



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




64,719,496✔





4891



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




32,378,149✔





4892



  QUERY_CHECK_CODE(code, lino, _end);




32,434,389✔





4893



  if (pInfo->filesetDelimited) {




32,434,389✔





4894



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




32,423,125✔





4895



  }










4896



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




32,448,311✔





4897












4898



  code = startDurationForGroupTableMergeScan(pOperator);




32,398,721✔





4899



  QUERY_CHECK_CODE(code, lino, _end);




32,424,287✔





4900












4901



_end:




32,366,935✔





4902



  if (code != TSDB_CODE_SUCCESS) {




32,425,153✔





4903



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




57,352✔





4904



    pTaskInfo->code = code;




57,352✔





4905



    T_LONG_JMP(pTaskInfo->env, code);




57,352✔





4906



  }










4907



}




32,367,801✔





4908












4909



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




32,338,337✔





4910



  STableMergeScanInfo* pInfo = pOperator->info;




32,338,337✔





4911



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




32,338,791✔





4912



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




32,337,846✔





4913












4914



  stopDurationForGroupTableMergeScan(pOperator);




32,335,048✔





4915












4916



  if (pInfo->base.dataReader != NULL) {




32,328,692✔





4917



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




32,333,760✔





4918



    pInfo->base.dataReader = NULL;




32,317,749✔





4919



  }










4920



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




32,320,132✔





4921



    if (pInfo->nextDurationBlocks[i]) {




1,042✔





4922



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,042✔





4923



      pInfo->nextDurationBlocks[i] = NULL;




1,042✔





4924



    }










4925



    pInfo->numNextDurationBlocks = 0;




1,042✔





4926



    pInfo->nextDurationBlocksIdx = 0;




1,042✔





4927



  }










4928



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




32,324,399✔





4929



  taosHashCleanup(pInfo->mSkipTables);




32,309,305✔





4930



  pInfo->mSkipTables = NULL;




32,310,913✔





4931



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




32,314,850✔





4932



}




32,323,443✔





4933












4934



// all data produced by this function only belongs to one group










4935



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










4936



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




83,715,569✔





4937



                                              SOperatorInfo* pOperator) {










4938



  STableMergeScanInfo* pInfo = pOperator->info;




83,715,569✔





4939



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




83,718,364✔





4940



  STupleHandle*        pTupleHandle = NULL;




83,716,971✔





4941












4942



  blockDataCleanup(pResBlock);




83,721,476✔





4943












4944



  while (1) {




×







4945



    while (1) {




2,147,483,647✔





4946



      pTupleHandle = NULL;




2,147,483,647✔





4947



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





4948



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





4949



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




7,614,749✔





4950



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




7,614,749✔





4951



      }










4952



      if (pTupleHandle == NULL) {




2,147,483,647✔





4953



        break;




71,341,349✔





4954



      }










4955












4956



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





4957



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





4958



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4959



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







4960



      }










4961












4962



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





4963



        break;




12,330,180✔





4964



      }










4965



    }










4966












4967



    if (tsortIsClosed(pHandle)) {




83,671,529✔





4968



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







4969



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







4970



    }










4971












4972



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




83,678,409✔





4973



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




83,675,430✔





4974



           pInfo->limitInfo.numOfOutputRows);










4975



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




83,676,415✔





4976



      break;










4977



    }










4978



  }










4979



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




83,676,415✔





4980



}










4981












4982



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




70,481,383✔





4983



  if (pOperator->status == OP_EXEC_DONE) {




70,481,383✔





4984



    (*ppRes) = NULL;




25,731✔





4985



    return TSDB_CODE_SUCCESS;




25,731✔





4986



  }










4987












4988



  int32_t              code = TSDB_CODE_SUCCESS;




70,376,565✔





4989



  int32_t              lino = 0;




70,376,565✔





4990



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




70,376,565✔





4991



  STableMergeScanInfo* pInfo = pOperator->info;




70,449,928✔





4992












4993



  code = pOperator->fpSet._openFn(pOperator);




70,425,137✔





4994



  QUERY_CHECK_CODE(code, lino, _end);




70,437,711✔





4995












4996



  int64_t st = taosGetTimestampUs();




70,465,082✔





4997












4998



  int32_t tableListSize = 0;




70,465,082✔





4999



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




70,449,566✔





5000



  QUERY_CHECK_CODE(code, lino, _end);




70,467,680✔





5001












5002



  if (!pInfo->hasGroupId) {




70,467,680✔





5003



    pInfo->hasGroupId = true;




29,094,783✔





5004












5005



    if (tableListSize == 0) {




29,003,736✔





5006



      setOperatorCompleted(pOperator);




2,702,559✔





5007



      (*ppRes) = NULL;




2,701,607✔





5008



      return code;




2,702,083✔





5009



    }










5010



    pInfo->tableStartIndex = 0;




26,301,177✔





5011



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




26,375,277✔





5012



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




26,289,488✔





5013



    pInfo->groupId = tmp->groupId;




26,289,488✔





5014



    startGroupTableMergeScan(pOperator);




26,371,936✔





5015



  }










5016












5017



  SSDataBlock* pBlock = NULL;




67,725,796✔





5018



  while (pInfo->tableStartIndex < tableListSize) {




83,704,378✔





5019



    if (isTaskKilled(pTaskInfo)) {




83,722,347✔





5020



      goto _end;




2,270✔





5021



    }










5022












5023



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




83,711,088✔





5024



                                              pOperator);










5025



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




83,675,210✔





5026



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,763,438✔





5027



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,763,438✔





5028



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,763,438✔





5029



    }










5030



    if (pBlock != NULL) {




83,676,081✔





5031



      pBlock->info.id.groupId = pInfo->groupId;




41,373,948✔





5032



      pOperator->resultInfo.totalRows += pBlock->info.rows;




41,369,862✔





5033



      pInfo->bGroupProcessed = true;




41,372,623✔





5034



      break;




41,364,905✔





5035



    } else {










5036



      if (pInfo->bNewFilesetEvent) {




42,302,133✔





5037



        stopDurationForGroupTableMergeScan(pOperator);




9,962,925✔





5038



        code = startDurationForGroupTableMergeScan(pOperator);




9,962,925✔





5039



        QUERY_CHECK_CODE(code, lino, _end);




9,959,520✔





5040



      } else {










5041



        // Data of this group are all dumped, let's try the next group










5042



        stopGroupTableMergeScan(pOperator);




32,339,208✔





5043



        if (pInfo->tableEndIndex >= tableListSize - 1) {




32,331,478✔





5044



          setOperatorCompleted(pOperator);




26,302,054✔





5045



          break;




26,305,375✔





5046



        }










5047












5048



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,019,062✔





5049



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,019,062✔





5050



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,019,062✔





5051



        pInfo->groupId = tmp->groupId;




6,019,062✔





5052



        startGroupTableMergeScan(pOperator);




6,019,062✔





5053



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,019,062✔





5054



      }










5055



    }










5056



  }










5057












5058



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




67,673,370✔





5059












5060



_end:




67,686,214✔





5061



  if (code != TSDB_CODE_SUCCESS) {




67,686,742✔





5062



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5063



    pTaskInfo->code = code;




×







5064



    T_LONG_JMP(pTaskInfo->env, code);




×







5065



  } else {










5066



    (*ppRes) = pBlock;




67,686,742✔





5067



  }










5068












5069



  return code;




67,690,725✔





5070



}










5071












5072



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5073



  SSDataBlock* pRes = NULL;




×







5074



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5075



  return pRes;




×







5076



}










5077












5078



void destroyTableMergeScanOperatorInfo(void* param) {




28,678,649✔





5079



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




28,678,649✔





5080












5081



  // start one reader variable










5082



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




28,678,649✔





5083



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




28,676,796✔





5084



    pTableScanInfo->base.dataReader = NULL;




28,664,684✔





5085



  }










5086












5087



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




28,669,707✔





5088



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5089



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5090



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5091



    }










5092



  }










5093












5094



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




28,682,212✔





5095



  pTableScanInfo->pSortHandle = NULL;




28,666,978✔





5096



  taosHashCleanup(pTableScanInfo->mSkipTables);




28,680,383✔





5097



  pTableScanInfo->mSkipTables = NULL;




28,660,822✔





5098



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




28,663,435✔





5099



  pTableScanInfo->pSortInputBlock = NULL;




28,669,812✔





5100



  // end one reader variable










5101












5102



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




28,670,294✔





5103












5104



  blockDataDestroy(pTableScanInfo->pResBlock);




28,677,914✔





5105



  pTableScanInfo->pResBlock = NULL;




28,680,385✔





5106












5107



  // remove it from the task->result list










5108



  blockDataDestroy(pTableScanInfo->pReaderBlock);




28,680,839✔





5109



  pTableScanInfo->pReaderBlock = NULL;




28,674,356✔





5110



  taosArrayDestroy(pTableScanInfo->pSortInfo);




28,678,032✔





5111












5112



  stopSubTablesTableMergeScan(pTableScanInfo);




28,672,385✔





5113












5114



  taosMemoryFreeClear(param);




28,666,257✔





5115



}




28,668,340✔





5116












5117



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,222,854✔





5118



  if (pOptr == NULL) {




1,222,854✔





5119



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5120



    return TSDB_CODE_INVALID_PARA;




×







5121



  }










5122



  // TODO: merge these two info into one struct










5123



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,222,854✔





5124



  if (!execInfo) {




1,222,339✔





5125



    return terrno;




×







5126



  }










5127



  STableMergeScanInfo* pInfo = pOptr->info;




1,222,339✔





5128



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,222,854✔





5129



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,222,339✔





5130












5131



  *pOptrExplain = execInfo;




1,222,854✔





5132



  *len = sizeof(STableMergeScanExecInfo);




1,222,339✔





5133












5134



  return TSDB_CODE_SUCCESS;




1,222,339✔





5135



}










5136












5137



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,292,842✔





5138



  int32_t         code = TSDB_CODE_SUCCESS;




2,292,842✔





5139



  STableMergeScanInfo*   pInfo = pOper->info;




2,292,842✔





5140



  pOper->status = OP_NOT_OPENED;




2,292,842✔





5141












5142



  pInfo->tableEndIndex = 0;




2,292,842✔





5143



  pInfo->tableStartIndex = 0;




2,292,842✔





5144



  pInfo->hasGroupId = false;




2,292,842✔





5145



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,292,842✔





5146



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,292,842✔





5147



  }










5148



  pInfo->base.dataReader = NULL;




2,292,842✔





5149



  pInfo->base.scanFlag = MAIN_SCAN;




2,292,842✔





5150












5151



  pInfo->base.limitInfo = (SLimitInfo){0};




2,292,842✔





5152



  pInfo->base.limitInfo.limit.limit = -1;




2,292,842✔





5153



  pInfo->base.limitInfo.slimit.limit = -1;




2,292,842✔





5154












5155



  tableListDestroy(pInfo->base.pTableListInfo);




2,292,842✔





5156



  pInfo->base.pTableListInfo = tableListCreate();




2,292,842✔





5157



  if (!pInfo->base.pTableListInfo) {




2,292,842✔





5158



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5159



    return terrno;




×







5160



  }










5161



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,292,483✔





5162












5163



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,292,724✔





5164



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,585,202✔





5165



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5166



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,585,443✔





5167



  if (code) {




2,292,842✔





5168



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5169



    return code;




×







5170



  }










5171












5172



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,292,842✔





5173



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,292,842✔





5174



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,292,601✔





5175



  if (code) {




2,292,597✔





5176



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5177



    return code;




×







5178



  }










5179












5180



  tsortDestroySortHandle(pInfo->pSortHandle);




2,292,597✔





5181



  pInfo->pSortHandle = NULL;




2,292,597✔





5182












5183



  taosHashCleanup(pInfo->mSkipTables);




2,292,597✔





5184



  pInfo->mSkipTables = NULL;




2,292,597✔





5185



  pOper->resultInfo.totalRows = 0;




2,292,597✔





5186



  










5187



  pInfo->bGroupProcessed = false;




2,292,597✔





5188



  pInfo->bNewFilesetEvent = false;




2,292,842✔





5189



  pInfo->bNextDurationBlockEvent = false;




2,292,842✔





5190



  pInfo->rtnNextDurationBlocks = false;




2,292,724✔





5191



  pInfo->nextDurationBlocksIdx = 0;




2,292,842✔





5192



  pInfo->bSortRowId = false;




2,292,724✔





5193












5194



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,292,842✔





5195



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5196



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5197



      pInfo->nextDurationBlocks[i] = NULL;




×







5198



    }










5199



  }










5200



  pInfo->numNextDurationBlocks = 0;




2,292,842✔





5201












5202



  stopSubTablesTableMergeScan(pInfo);




2,292,842✔





5203



  return code;




2,292,479✔





5204



}










5205












5206



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




28,627,402✔





5207



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5208



                                         SOperatorInfo** pOptrInfo) {










5209



  QRY_PARAM_CHECK(pOptrInfo);




28,627,402✔





5210












5211



  int32_t              code = TSDB_CODE_SUCCESS;




28,650,529✔





5212



  int32_t              lino = 0;




28,650,529✔





5213



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




28,650,529✔





5214



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




28,564,338✔





5215



  if (pInfo == NULL || pOperator == NULL) {




28,552,361✔





5216



    code = terrno;




757✔





5217



    goto _error;




×







5218



  }










5219












5220



  pOperator->pPhyNode = pTableScanNode;




28,551,604✔





5221



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




28,559,960✔





5222












5223



  int32_t numOfCols = 0;




28,566,995✔





5224



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




28,583,909✔





5225



                             &pInfo->base.matchInfo);










5226



  QUERY_CHECK_CODE(code, lino, _error);




28,629,351✔





5227












5228



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




28,629,351✔





5229



  QUERY_CHECK_CODE(code, lino, _error);




28,600,895✔





5230












5231



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




28,600,895✔





5232



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,246,910✔





5233



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,261,753✔





5234



    QUERY_CHECK_CODE(code, lino, _error);




10,263,702✔





5235












5236



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,263,702✔





5237



                                      &pTaskInfo->storageAPI.functionStore);










5238



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,248,746✔





5239



  }










5240












5241



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




28,637,714✔





5242












5243



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




28,507,321✔





5244



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







5245



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5246



  }










5247












5248



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




28,507,321✔





5249



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




28,613,495✔





5250



  pInfo->base.scanFlag = MAIN_SCAN;




28,505,605✔





5251



  pInfo->base.readHandle = *readHandle;




28,535,401✔





5252












5253



  pInfo->readIdx = -1;




28,614,557✔





5254












5255



  pInfo->base.limitInfo.limit.limit = -1;




28,504,775✔





5256



  pInfo->base.limitInfo.slimit.limit = -1;




28,556,438✔





5257



  pInfo->base.pTableListInfo = pTableListInfo;




28,546,481✔





5258












5259



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




28,629,260✔





5260



  pInfo->sample.seed = taosGetTimestampSec();




28,528,957✔





5261












5262



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




28,603,926✔





5263



                            pTaskInfo->pStreamRuntimeInfo);




28,589,823✔





5264



  QUERY_CHECK_CODE(code, lino, _error);




28,574,389✔





5265












5266



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




28,574,389✔





5267












5268



  pInfo->mergeLimit = -1;




28,571,202✔





5269



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




28,609,541✔





5270



  if (hasLimit) {




28,523,797✔





5271



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




3,060,103✔





5272



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




791,354✔





5273



                            : pInfo->limitInfo.limit.limit;




2,321,133✔





5274



    pInfo->mSkipTables = NULL;




1,529,288✔





5275



  }










5276












5277



  initResultSizeInfo(&pOperator->resultInfo, 1024);




28,523,945✔





5278



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




28,594,805✔





5279



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




28,666,654✔





5280



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




28,553,538✔





5281



  QUERY_CHECK_CODE(code, lino, _error);




28,656,551✔





5282



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




28,656,551✔





5283



    pInfo->bSortRowId = true;




5,197,653✔





5284



  } else {










5285



    pInfo->bSortRowId = false;




23,464,262✔





5286



  }










5287












5288



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




28,636,796✔





5289



  QUERY_CHECK_CODE(code, lino, _error);




28,616,996✔





5290












5291



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




28,616,996✔





5292



  QUERY_CHECK_CODE(code, lino, _error);




28,600,756✔





5293












5294



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




28,600,756✔





5295



  QUERY_CHECK_CODE(code, lino, _error);




28,637,033✔





5296












5297



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




28,637,033✔





5298












5299



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




28,653,806✔





5300



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




28,638,186✔





5301












5302



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




28,581,729✔





5303












5304



  // start one reader variable










5305



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




28,635,845✔





5306



  QUERY_CHECK_CODE(code, lino, _error);




28,645,874✔





5307












5308



  if (!tsExperimental) {




28,645,874✔





5309



    pInfo->filesetDelimited = false;




×







5310



  } else {










5311



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




28,645,874✔





5312



  }










5313



  // end one reader variable










5314



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




28,616,662✔





5315



                  pInfo, pTaskInfo);










5316



  pOperator->exprSupp.numOfExprs = numOfCols;




28,606,156✔





5317












5318



  pOperator->fpSet = createOperatorFpSet(




28,603,867✔





5319



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




28,650,809✔





5320



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5321



      NULL);










5322



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




28,593,765✔





5323



  pOperator->cost.openCost = 0;




28,635,483✔





5324












5325



  *pOptrInfo = pOperator;




28,648,204✔





5326



  return code;




28,541,876✔





5327












5328



_error:




×







5329



  if (code != TSDB_CODE_SUCCESS) {




×







5330



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5331



  }










5332



  pTaskInfo->code = code;




×







5333



  if (pInfo != NULL) {




×







5334



    pInfo->base.pTableListInfo = NULL;




×







5335



    destroyTableMergeScanOperatorInfo(pInfo);




×







5336



  }










5337



  if (pOperator != NULL) {




×







5338



    pOperator->info = NULL;




×







5339



    destroyOperator(pOperator);




×







5340



  }










5341



  return code;




×







5342



}










5343












5344



// ====================================================================================================================










5345



// TableCountScanOperator










5346



static void        destoryTableCountScanOperator(void* param);










5347



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5348



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5349



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5350



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5351



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5352



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5353



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5354



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5355



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5356



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5357



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5358



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5359



                                               size_t perfdbTableNum);










5360



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5361



                                              size_t infodbTableNum, size_t perfdbTableNum);










5362



static const char* GROUP_TAG_DB_NAME = "db_name";










5363



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5364












5365



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




26,052✔





5366



  if (scanCols != NULL) {




26,052✔





5367



    SNode* pNode = NULL;




14,590✔





5368



    FOREACH(pNode, scanCols) {




34,064✔





5369



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




19,474✔





5370



        return TSDB_CODE_QRY_SYS_ERROR;




×







5371



      }










5372



      STargetNode* targetNode = (STargetNode*)pNode;




19,474✔





5373



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




19,474✔





5374



        return TSDB_CODE_QRY_SYS_ERROR;




×







5375



      }










5376



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




19,474✔





5377



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,474✔





5378



        supp->dbNameSlotId = targetNode->slotId;




9,601✔





5379



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




9,873✔





5380



        supp->stbNameSlotId = targetNode->slotId;




9,873✔





5381



      }










5382



    }










5383



  }










5384



  return TSDB_CODE_SUCCESS;




26,052✔





5385



}










5386












5387



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




26,052✔





5388



  if (pseudoCols != NULL) {




26,052✔





5389



    SNode* pNode = NULL;




26,052✔





5390



    FOREACH(pNode, pseudoCols) {




52,104✔





5391



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




26,052✔





5392



        return TSDB_CODE_QRY_SYS_ERROR;




×







5393



      }










5394



      STargetNode* targetNode = (STargetNode*)pNode;




26,052✔





5395



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




26,052✔





5396



        return TSDB_CODE_QRY_SYS_ERROR;




×







5397



      }










5398



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




26,052✔





5399



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




26,052✔





5400



        supp->tbCountSlotId = targetNode->slotId;




26,052✔





5401



      }










5402



    }










5403



  }










5404



  return TSDB_CODE_SUCCESS;




26,052✔





5405



}










5406












5407



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




26,052✔





5408



  if (groupTags != NULL) {




26,052✔





5409



    SNode* pNode = NULL;




14,590✔





5410



    FOREACH(pNode, groupTags) {




34,064✔





5411



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




19,474✔





5412



        return TSDB_CODE_QRY_SYS_ERROR;




×







5413



      }










5414



      SColumnNode* colNode = (SColumnNode*)pNode;




19,474✔





5415



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,474✔





5416



        supp->groupByDbName = true;




9,601✔





5417



      }










5418



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




19,474✔





5419



        supp->groupByStbName = true;




9,873✔





5420



      }










5421



    }










5422



  } else {










5423



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




11,462✔





5424



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




11,462✔





5425



  }










5426



  return TSDB_CODE_SUCCESS;




26,052✔





5427



}










5428












5429



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




26,052✔





5430



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5431



  int32_t code = 0;




26,052✔





5432



  code = tblCountScanGetInputs(groupTags, tableName, supp);




26,052✔





5433



  if (code != TSDB_CODE_SUCCESS) {




26,052✔





5434



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5435



    return code;




×







5436



  }










5437












5438



  supp->dbNameSlotId = -1;




26,052✔





5439



  supp->stbNameSlotId = -1;




26,052✔





5440



  supp->tbCountSlotId = -1;




26,052✔





5441












5442



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




26,052✔





5443



  if (code != TSDB_CODE_SUCCESS) {




26,052✔





5444



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5445



    return code;




×







5446



  }










5447












5448



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




26,052✔





5449



  if (code != TSDB_CODE_SUCCESS) {




26,052✔





5450



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5451



    return code;




×







5452



  }










5453



  return code;




26,052✔





5454



}










5455












5456



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




26,052✔





5457



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5458



  QRY_PARAM_CHECK(pOptrInfo);




26,052✔





5459












5460



  int32_t                      code = TSDB_CODE_SUCCESS;




26,052✔





5461



  int32_t                      lino = 0;




26,052✔





5462



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




26,052✔





5463



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




26,052✔





5464



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




26,052✔





5465



  if (!pInfo || !pOperator) {




26,052✔





5466



    code = terrno;




×







5467



    goto _error;




×







5468



  }










5469












5470



  pInfo->readHandle = *readHandle;




26,052✔





5471












5472



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




26,052✔





5473



  initResultSizeInfo(&pOperator->resultInfo, 1);




26,052✔





5474



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




26,052✔





5475



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




26,052✔





5476












5477



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




26,052✔





5478



  QUERY_CHECK_CODE(code, lino, _error);




26,052✔





5479












5480



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




26,052✔





5481



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5482



                               pTaskInfo);










5483



  QUERY_CHECK_CODE(code, lino, _error);




26,052✔





5484












5485



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




26,052✔





5486



                  pInfo, pTaskInfo);










5487



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




26,052✔





5488



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5489



  *pOptrInfo = pOperator;




26,052✔





5490



  return code;




26,052✔





5491












5492



_error:




×







5493



  if (pInfo != NULL) {




×







5494



    destoryTableCountScanOperator(pInfo);




×







5495



  }










5496



  if (pOperator != NULL) {




×







5497



    pOperator->info = NULL;




×







5498



    destroyOperator(pOperator);




×







5499



  }










5500



  pTaskInfo->code = code;




×







5501



  return code;




×







5502



}










5503












5504



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




36,090✔





5505



                                    SSDataBlock* pRes) {










5506



  int32_t code = TSDB_CODE_SUCCESS;




36,090✔





5507



  int32_t lino = 0;




36,090✔





5508



  if (pSupp->dbNameSlotId != -1) {




36,090✔





5509



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




14,512✔





5510



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




14,512✔





5511



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




14,512✔





5512












5513



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,512✔





5514



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




14,512✔





5515












5516



    varDataSetLen(varDbName, strlen(dbName));




14,512✔





5517



    code = colDataSetVal(colInfoData, 0, varDbName, false);




14,512✔





5518



    QUERY_CHECK_CODE(code, lino, _end);




14,512✔





5519



  }










5520












5521



  if (pSupp->stbNameSlotId != -1) {




36,090✔





5522



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




18,958✔





5523



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




18,958✔





5524



    if (strlen(stbName) != 0) {




18,958✔





5525



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,656✔





5526



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




13,656✔





5527



      varDataSetLen(varStbName, strlen(stbName));




13,656✔





5528



      code = colDataSetVal(colInfoData, 0, varStbName, false);




13,656✔





5529



      QUERY_CHECK_CODE(code, lino, _end);




13,656✔





5530



    } else {










5531



      colDataSetNULL(colInfoData, 0);










5532



    }










5533



  }










5534












5535



  if (pSupp->tbCountSlotId != -1) {




36,090✔





5536



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




36,090✔





5537



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




36,090✔





5538



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




36,090✔





5539



    QUERY_CHECK_CODE(code, lino, _end);




36,090✔





5540



  }










5541



  pRes->info.rows = 1;




36,090✔





5542












5543



_end:




36,090✔





5544



  if (code != TSDB_CODE_SUCCESS) {




36,090✔





5545



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5546



  }










5547



  return code;




36,090✔





5548



}










5549












5550



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




10,616✔





5551



  STableCountScanSupp* pSupp = &pInfo->supp;




10,616✔





5552



  SSDataBlock*         pRes = pInfo->pRes;




10,616✔





5553












5554



  size_t infodbTableNum;




10,616✔





5555



  getInfosDbMeta(NULL, &infodbTableNum);




10,616✔





5556



  infodbTableNum -= 1;




10,616✔





5557



  size_t perfdbTableNum;




10,616✔





5558



  getPerfDbMeta(NULL, &perfdbTableNum);




10,616✔





5559












5560



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




10,616✔





5561



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,138✔





5562



    return (pRes->info.rows > 0) ? pRes : NULL;




9,138✔





5563



  } else {










5564



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,478✔





5565



    return (pRes->info.rows > 0) ? pRes : NULL;




1,478✔





5566



  }










5567



}










5568












5569



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,478✔





5570



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5571



  int32_t        code = TSDB_CODE_SUCCESS;




1,478✔





5572



  int32_t        lino = 0;




1,478✔





5573



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,478✔





5574



  if (strlen(pSupp->stbNameFilter) != 0) {




1,478✔





5575



    // sys dbs do not contain any stable, so the count is always 0










5576



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




501✔





5577



    QUERY_CHECK_CODE(code, lino, _end);




501✔





5578



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




977✔





5579



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




167✔





5580



    QUERY_CHECK_CODE(code, lino, _end);




167✔





5581



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




810✔





5582



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×







5583



    QUERY_CHECK_CODE(code, lino, _end);




×







5584



  } else if (strlen(pSupp->dbNameFilter) == 0) {




810✔





5585



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




643✔





5586



    QUERY_CHECK_CODE(code, lino, _end);




643✔





5587



  } else {










5588



    // other dbs do not exist in sys dbs, so the count is always 0










5589



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




167✔





5590



    QUERY_CHECK_CODE(code, lino, _end);




167✔





5591



  }










5592












5593



_end:




167✔





5594



  if (code != TSDB_CODE_SUCCESS) {




1,478✔





5595



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5596



    pTaskInfo->code = code;




×







5597



    T_LONG_JMP(pTaskInfo->env, code);




×







5598



  }










5599



  setOperatorCompleted(pOperator);




1,478✔





5600



}




1,478✔





5601












5602



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,138✔





5603



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5604



                                        size_t perfdbTableNum) {










5605



  int32_t        code = TSDB_CODE_SUCCESS;




9,138✔





5606



  int32_t        lino = 0;




9,138✔





5607



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,138✔





5608



  if (pInfo->currGrpIdx == 0) {




9,138✔





5609



    uint64_t groupId = 0;




3,046✔





5610



    if (pSupp->groupByDbName) {




3,046✔





5611



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,073✔





5612



    } else {










5613



      groupId = calcGroupId("", 0);




973✔





5614



    }










5615












5616



    pRes->info.id.groupId = groupId;




3,046✔





5617



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,046✔





5618



    QUERY_CHECK_CODE(code, lino, _end);




3,046✔





5619



  } else if (pInfo->currGrpIdx == 1) {




6,092✔





5620



    uint64_t groupId = 0;




3,046✔





5621



    if (pSupp->groupByDbName) {




3,046✔





5622



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,073✔





5623



    } else {










5624



      groupId = calcGroupId("", 0);




973✔





5625



    }










5626












5627



    pRes->info.id.groupId = groupId;




3,046✔





5628



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,046✔





5629



    QUERY_CHECK_CODE(code, lino, _end);




3,046✔





5630



  } else {










5631



    setOperatorCompleted(pOperator);




3,046✔





5632



  }










5633



  pInfo->currGrpIdx++;




9,138✔





5634












5635



_end:




9,138✔





5636



  if (code != TSDB_CODE_SUCCESS) {




9,138✔





5637



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5638



    pTaskInfo->code = code;




×







5639



    T_LONG_JMP(pTaskInfo->env, code);




×







5640



  }










5641



}




9,138✔





5642












5643



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




62,142✔





5644



  int32_t                      code = TSDB_CODE_SUCCESS;




62,142✔





5645



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




62,142✔





5646



  STableCountScanOperatorInfo* pInfo = pOperator->info;




62,142✔





5647



  STableCountScanSupp*         pSupp = &pInfo->supp;




62,142✔





5648



  SSDataBlock*                 pRes = pInfo->pRes;




62,142✔





5649












5650



  blockDataCleanup(pRes);




62,142✔





5651



  QRY_PARAM_CHECK(ppRes);




62,142✔





5652












5653



  if (pOperator->status == OP_EXEC_DONE) {




62,142✔





5654



    return code;




15,226✔





5655



  }










5656












5657



  if (pInfo->readHandle.mnd != NULL) {




46,916✔





5658



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




10,616✔





5659



    return code;




10,616✔





5660



  }










5661












5662



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




36,300✔





5663



  if (code != TSDB_CODE_SUCCESS) {




36,300✔





5664



    qError("%s failed since %s", __func__, tstrerror(code));




×







5665



    pTaskInfo->code = code;




×







5666



    T_LONG_JMP(pTaskInfo->env, code);




×







5667



  }










5668



  if (pRes->info.rows > 0) {




36,300✔





5669



    *ppRes = pRes;




28,520✔





5670



  }










5671












5672



  return code;




36,300✔





5673



}










5674












5675



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




36,300✔





5676



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5677



  int32_t        code = TSDB_CODE_SUCCESS;




36,300✔





5678



  int32_t        lino = 0;




36,300✔





5679



  const char*    db = NULL;




36,300✔





5680



  int32_t        vgId = 0;




36,300✔





5681



  char           dbName[TSDB_DB_NAME_LEN] = {0};




36,300✔





5682



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




36,300✔





5683



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




36,300✔





5684












5685



  // get dbname










5686



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




36,300✔





5687



  SName sn = {0};




36,300✔





5688












5689



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




36,300✔





5690



  QUERY_CHECK_CODE(code, lino, _end);




36,300✔





5691












5692



  code = tNameGetDbName(&sn, dbName);




36,300✔





5693



  QUERY_CHECK_CODE(code, lino, _end);




36,300✔





5694












5695



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




36,300✔





5696



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




26,316✔





5697



  } else {










5698



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




9,984✔





5699



  }










5700












5701



_end:




36,300✔





5702



  if (code != TSDB_CODE_SUCCESS) {




36,300✔





5703



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5704



    pTaskInfo->code = code;




×







5705



  }










5706












5707



  return code;




36,300✔





5708



}










5709












5710



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




26,316✔





5711



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5712



  int32_t        code = TSDB_CODE_SUCCESS;




26,316✔





5713



  int32_t        lino = 0;




26,316✔





5714



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




26,316✔





5715



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




26,316✔





5716












5717



  if (pSupp->groupByStbName) {




26,316✔





5718



    if (pInfo->stbUidList == NULL) {




22,552✔





5719



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




7,780✔





5720



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




7,780✔





5721



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




7,780✔





5722



      QUERY_CHECK_CODE(code, lino, _end);




7,780✔





5723



    }










5724












5725



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




22,552✔





5726



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




13,656✔





5727



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




13,656✔





5728



      QUERY_CHECK_CODE(code, lino, _end);




13,656✔





5729












5730



      pInfo->currGrpIdx++;




13,656✔





5731



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




8,896✔





5732



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




7,780✔





5733



      QUERY_CHECK_CODE(code, lino, _end);




7,780✔





5734












5735



      pInfo->currGrpIdx++;




7,780✔





5736



    } else {










5737



      setOperatorCompleted(pOperator);




1,116✔





5738



    }










5739



  } else {










5740



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




3,764✔





5741



    pRes->info.id.groupId = groupId;




3,764✔





5742












5743



    int64_t dbTableCount = 0;




3,764✔





5744



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




3,764✔





5745



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




3,764✔





5746



    QUERY_CHECK_CODE(code, lino, _end);




3,764✔





5747



    setOperatorCompleted(pOperator);




3,764✔





5748



  }










5749












5750



_end:




26,316✔





5751



  if (code != TSDB_CODE_SUCCESS) {




26,316✔





5752



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5753



    pTaskInfo->code = code;




×







5754



  }










5755



  return code;




26,316✔





5756



}










5757












5758



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,984✔





5759



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5760



  int32_t        code = TSDB_CODE_SUCCESS;




9,984✔





5761



  int32_t        lino = 0;




9,984✔





5762



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,984✔





5763



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,984✔





5764












5765



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




9,984✔





5766



    // db name not match, return count 0










5767



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×







5768



    QUERY_CHECK_CODE(code, lino, _end);




×







5769



  } else if (strlen(pSupp->stbNameFilter) != 0) {




9,984✔





5770



    uint64_t uid = 0;




2,956✔





5771



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




2,956✔





5772



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




2,956✔





5773



      // table not exist, return count 0










5774



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,336✔





5775



      QUERY_CHECK_CODE(code, lino, _end);




1,336✔





5776



    } else {










5777



      QUERY_CHECK_CODE(code, lino, _end);




1,620✔





5778












5779



      int64_t numOfChildTables = 0;




1,620✔





5780



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




1,620✔





5781



      QUERY_CHECK_CODE(code, lino, _end);




1,620✔





5782












5783



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




1,620✔





5784



      QUERY_CHECK_CODE(code, lino, _end);




1,620✔





5785



    }










5786



  } else {










5787



    int64_t tbNumVnode = 0;




7,028✔





5788



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




7,028✔





5789



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




7,028✔





5790



    QUERY_CHECK_CODE(code, lino, _end);




7,028✔





5791



  }










5792












5793



_end:




9,984✔





5794



  if (code != TSDB_CODE_SUCCESS) {




9,984✔





5795



    pTaskInfo->code = code;




×







5796



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5797



  }










5798












5799



  setOperatorCompleted(pOperator);




9,984✔





5800



  return code;




9,984✔





5801



}










5802












5803



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




7,780✔





5804



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5805



  int32_t code = TSDB_CODE_SUCCESS;




7,780✔





5806



  int32_t lino = 0;




7,780✔





5807



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




7,780✔





5808



  if (pSupp->groupByDbName) {




7,780✔





5809



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




3,764✔





5810



  }










5811












5812



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




7,780✔





5813



  pRes->info.id.groupId = groupId;




7,780✔





5814












5815



  int64_t numOfTables = 0;




7,780✔





5816



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




7,780✔





5817












5818



  if (numOfTables != 0) {




7,780✔





5819



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,116✔





5820



  }










5821












5822



_end:




6,664✔





5823



  if (code != TSDB_CODE_SUCCESS) {




7,780✔





5824



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5825



  }










5826



  return code;




7,780✔





5827



}










5828












5829



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




13,656✔





5830



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5831



  int32_t code = TSDB_CODE_SUCCESS;




13,656✔





5832



  int32_t lino = 0;




13,656✔





5833



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,656✔





5834



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




13,656✔





5835



  QUERY_CHECK_CODE(code, lino, _end);




13,656✔





5836












5837



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




13,656✔





5838



  if (pSupp->groupByDbName) {




13,656✔





5839



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,292✔





5840



  } else {










5841



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,364✔





5842



  }










5843












5844



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




13,656✔





5845



  pRes->info.id.groupId = groupId;




13,501✔





5846












5847



  int64_t ctbNum = 0;




13,501✔





5848



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




13,656✔





5849



  QUERY_CHECK_CODE(code, lino, _end);




13,656✔





5850



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




13,656✔





5851



  QUERY_CHECK_CODE(code, lino, _end);




13,656✔





5852












5853



_end:




13,656✔





5854



  if (code != TSDB_CODE_SUCCESS) {




13,656✔





5855



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5856



  }










5857



  return code;




13,656✔





5858



}










5859












5860



static void destoryTableCountScanOperator(void* param) {




26,052✔





5861



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




26,052✔





5862



  blockDataDestroy(pTableCountScanInfo->pRes);




26,052✔





5863












5864



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




26,052✔





5865



  taosMemoryFreeClear(param);




26,052✔





5866



}




26,052✔



















    

  • 

    •